Class: GraphQL::Schema::Enum

Inherits:
Member
  • Object
show all
Extended by:
Member::ValidatesInput
Defined in:
lib/graphql/schema/enum.rb

Overview

Extend this class to define GraphQL enums in your schema.

By default, GraphQL enum values are translated into Ruby strings. You can provide a custom value with the value: keyword.

Examples:

# equivalent to
# enum PizzaTopping {
#   MUSHROOMS
#   ONIONS
#   PEPPERS
# }
class PizzaTopping < GraphQL::Schema::Enum
  value :MUSHROOMS
  value :ONIONS
  value :PEPPERS
end

Defined Under Namespace

Classes: MissingValuesError, UnresolvedValueError

Constant Summary

Constants included from Member::GraphQLTypeNames

Member::GraphQLTypeNames::Boolean, Member::GraphQLTypeNames::ID, Member::GraphQLTypeNames::Int

Instance Attribute Summary

Attributes included from Member::BaseDSLMethods

#default_graphql_name, #graphql_name

Attributes included from Member::RelayShortcuts

#connection_type, #connection_type_class, #edge_type, #edge_type_class

Attributes included from Member::HasAstNode

#ast_node

Class Method Summary collapse

Methods included from Member::ValidatesInput

coerce_isolated_input, coerce_isolated_result, valid_input?, valid_isolated_input?, validate_input

Methods included from Member::BaseDSLMethods

#authorized?, #comment, #default_relay, #description, #introspection, #introspection?, #mutation, #name, #visible?

Methods included from Member::BaseDSLMethods::ConfigurationExtension

#inherited

Methods included from Member::TypeSystemHelpers

#initialize, #kind, #list?, #non_null?, #to_list_type, #to_non_null_type, #to_type_signature

Methods included from Member::Scoped

#inherited, #reauthorize_scoped_objects, #scope_items

Methods included from Member::HasPath

#path

Methods included from Member::HasAstNode

#inherited

Methods included from Member::HasDirectives

add_directive, #directive, #directives, get_directives, #inherited, #remove_directive, remove_directive

Class Method Details

.all_enum_value_definitions ⇒ Array<Schema::EnumValue>

Returns An unfiltered list of all definitions.

Returns:



130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/graphql/schema/enum.rb', line 130

def all_enum_value_definitions
  all_defns = if superclass.respond_to?(:all_enum_value_definitions)
    superclass.all_enum_value_definitions
  else
    []
  end

  @own_values && @own_values.each do |_key, value|
    if value.is_a?(Array)
      all_defns.concat(value)
    else
      all_defns << value
    end
  end

  all_defns
end

.coerce_input(value_name, ctx) ⇒ Object

Called by the runtime with incoming string representations from a query. It will match the string to a configured by name or by Ruby value.

Parameters:

  • value_name (String, Object) —

    A string from a GraphQL query, or a Ruby value matching a value(..., value: ...) configuration

  • ctx (GraphQL::Query::Context)

Returns:

Raises:



216
217
218
219
220
221
222
223
224
225
226
227
228
229
 
# File 'lib/graphql/schema/enum.rb', line 216

def coerce_input(value_name, ctx)
  all_values = ctx.types ? ctx.types.enum_values(self) : values.each_value

  # This tries matching by incoming GraphQL string, then checks Ruby-defined values
  if v = (all_values.find { |val| val.graphql_name == value_name } || all_values.find { |val| val.value == value_name })
    if v.authorized?(ctx)
      v.value
    else
      raise GraphQL::UnauthorizedEnumValueError.new(type: self, enum_value: v, context: ctx)
    end
  else
    nil
  end
end

.coerce_result(value, ctx) ⇒ String

Called by the runtime when a field returns a value to give back to the client. This method checks that the incoming value matches one of the enum’s defined values.

Parameters:

Returns:

  • (String) —

    The GraphQL-ready string for value

Raises:



199
200
201
202
203
204
205
206
207
208
 
# File 'lib/graphql/schema/enum.rb', line 199

def coerce_result(value, ctx)
  types = ctx.types
  all_values = types ? types.enum_values(self) : values.each_value
  enum_value = all_values.find { |val| val.value == value }
  if enum_value && (was_authed = enum_value.authorized?(ctx))
    enum_value.graphql_name
  else
    raise self::UnresolvedValueError.new(enum: self, value: value, context: ctx, authorized: was_authed)
  end
end

.enum_value_class(new_enum_value_class = nil) ⇒ Class

Returns for handling value(...) inputs and building GraphQL::Enum::EnumValues out of them.

Returns:

  • (Class) —

    for handling value(...) inputs and building GraphQL::Enum::EnumValues out of them



154
155
156
157
158
159
160
161
162
 
# File 'lib/graphql/schema/enum.rb', line 154

def enum_value_class(new_enum_value_class = nil)
  if new_enum_value_class
    @enum_value_class = new_enum_value_class
  elsif defined?(@enum_value_class) && @enum_value_class
    @enum_value_class
  else
    superclass <= GraphQL::Schema::Enum ? superclass.enum_value_class : nil
  end
end

.enum_values(context = GraphQL::Query::NullContext.instance) ⇒ Array<GraphQL::Schema::EnumValue>

Returns Possible values of this enum.

Returns:



93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/graphql/schema/enum.rb', line 93

def enum_values(context = GraphQL::Query::NullContext.instance)
  inherited_values = superclass.respond_to?(:enum_values) ? superclass.enum_values(context) : nil
  visible_values = []
  types = Warden.types_from_context(context)
  own_values.each do |key, values_entry|
    visible_value = nil
    if values_entry.is_a?(Array)
      values_entry.each do |v|
        if types.visible_enum_value?(v, context)
          if visible_value.nil?
            visible_value = v
            visible_values << v
          else
            raise DuplicateNamesError.new(
              duplicated_name: v.path, duplicated_definition_1: visible_value.inspect, duplicated_definition_2: v.inspect
            )
          end
        end
      end
    elsif types.visible_enum_value?(values_entry, context)
      visible_values << values_entry
    end
  end

  if inherited_values
    # Local values take precedence over inherited ones
    inherited_values.each do |i_val|
      if !visible_values.any? { |v| v.graphql_name == i_val.graphql_name }
        visible_values << i_val
      end
    end
  end

  visible_values
end

.kind ⇒ Object 



176
177
178
 
# File 'lib/graphql/schema/enum.rb', line 176

def kind
  GraphQL::TypeKinds::ENUM
end

.validate_non_null_input(value_name, ctx, max_errors: nil) ⇒ Object 



180
181
182
183
184
185
186
187
188
189
190
191
 
# File 'lib/graphql/schema/enum.rb', line 180

def validate_non_null_input(value_name, ctx, max_errors: nil)
  allowed_values = ctx.types.enum_values(self)
  matching_value = allowed_values.find { |v| v.graphql_name == value_name }

  if matching_value.nil?
    GraphQL::Query::InputValidationResult.from_problem("Expected #{GraphQL::Language.serialize(value_name)} to be one of: #{allowed_values.map(&:graphql_name).join(', ')}")
  else
    nil
  end
# rescue MissingValuesError
#   nil
end

.value(*args, value_method: nil, **kwargs, &block) ⇒ void

This method returns an undefined value.

Define a value for this enum

Parameters:

  • value_method (Symbol, false) (defaults to: nil) —

    A method to generate for this value, or false to skip generation

  • kwargs (Hash) —

    a customizable set of options

Options Hash (**kwargs):

  • :graphql_name (String, Symbol) —

    the GraphQL value for this, usually SCREAMING_CASE

  • :description, (String) —

    the GraphQL description for this value, present in documentation

  • :comment, (String) —

    the GraphQL comment for this value, present in documentation

  • :value (::Object) —

    the translated Ruby value for this object (defaults to graphql_name)

  • :value_method, (::Object) —

    the method name to fetch graphql_name (defaults to graphql_name.downcase)

  • :deprecation_reason (String) —

    if this object is deprecated, include a message here

See Also:

  • which handles these inputs by default


69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/graphql/schema/enum.rb', line 69

def value(*args, value_method: nil, **kwargs, &block)
  kwargs[:owner] = self
  value = enum_value_class.new(*args, **kwargs, &block)

  if value_method || (value_methods && value_method != false)
    generate_value_method(value, value_method)
  end

  key = value.graphql_name
  prev_value = own_values[key]
  case prev_value
  when nil
    own_values[key] = value
  when GraphQL::Schema::EnumValue
    own_values[key] = [prev_value, value]
  when Array
    prev_value << value
  else
    raise "Invariant: Unexpected enum value for #{key.inspect}: #{prev_value.inspect}"
  end
  value
end

.value_methods(new_value = NOT_CONFIGURED) ⇒ Object 



164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/graphql/schema/enum.rb', line 164

def value_methods(new_value = NOT_CONFIGURED)
  if NOT_CONFIGURED.equal?(new_value)
    if @value_methods != nil
      @value_methods
    else
      find_inherited_value(:value_methods, false)
    end
  else
    @value_methods = new_value
  end
end

.values(context = GraphQL::Query::NullContext.instance) ⇒ Hash<String => GraphQL::Schema::EnumValue>

Returns Possible values of this enum, keyed by name.

Returns:



149
150
151
 
# File 'lib/graphql/schema/enum.rb', line 149

def values(context = GraphQL::Query::NullContext.instance)
  enum_values(context).each_with_object({}) { |val, obj| obj[val.graphql_name] = val }
end