graphql 2.4.3 → 2.5.2

data/lib/graphql/query/context.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require "graphql/query/context/scoped_context"
 
 module GraphQL
   class Query
@@ -104,7 +103,7 @@ module GraphQL
           if key == :current_path
             current_path
           else
-            (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
+            (current_runtime_state = Fiber[:__graphql_runtime_info]) &&
               (query_runtime_state = current_runtime_state[@query]) &&
               (query_runtime_state.public_send(key))
           end
@@ -144,7 +143,7 @@ module GraphQL
       end
 
       def current_path
-        current_runtime_state = Thread.current[:__graphql_runtime_info]
+        current_runtime_state = Fiber[:__graphql_runtime_info]
         query_runtime_state = current_runtime_state && current_runtime_state[@query]
 
         path = query_runtime_state &&
@@ -169,7 +168,7 @@ module GraphQL
 
       def fetch(key, default = UNSPECIFIED_FETCH_DEFAULT)
         if RUNTIME_METADATA_KEYS.include?(key)
-          (runtime = Thread.current[:__graphql_runtime_info]) &&
+          (runtime = Fiber[:__graphql_runtime_info]) &&
             (query_runtime_state = runtime[@query]) &&
             (query_runtime_state.public_send(key))
         elsif @scoped_context.key?(key)
@@ -187,7 +186,7 @@ module GraphQL
 
       def dig(key, *other_keys)
         if RUNTIME_METADATA_KEYS.include?(key)
-          (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
+          (current_runtime_state = Fiber[:__graphql_runtime_info]) &&
             (query_runtime_state = current_runtime_state[@query]) &&
             (obj = query_runtime_state.public_send(key)) &&
             if other_keys.empty?
@@ -289,3 +288,5 @@ module GraphQL
     end
   end
 end
+
+require "graphql/query/context/scoped_context"

data/lib/graphql/query/variable_validation_error.rb

@@ -10,7 +10,7 @@ module GraphQL
 
         msg ||= "Variable $#{variable_ast.name} of type #{type.to_type_signature} was provided invalid value"
 
-        if problem_fields.any?
+        if !problem_fields.empty?
           msg += " for #{problem_fields.join(", ")}"
         end
 

data/lib/graphql/query.rb

@@ -1,19 +1,21 @@
 # frozen_string_literal: true
-require "graphql/query/context"
-require "graphql/query/fingerprint"
-require "graphql/query/null_context"
-require "graphql/query/result"
-require "graphql/query/variables"
-require "graphql/query/input_validation_result"
-require "graphql/query/variable_validation_error"
-require "graphql/query/validation_pipeline"
 
 module GraphQL
   # A combination of query string and {Schema} instance which can be reduced to a {#result}.
   class Query
+    extend Autoload
     include Tracing::Traceable
     extend Forwardable
 
+    autoload :Context, "graphql/query/context"
+    autoload :Fingerprint, "graphql/query/fingerprint"
+    autoload :NullContext, "graphql/query/null_context"
+    autoload :Result, "graphql/query/result"
+    autoload :Variables, "graphql/query/variables"
+    autoload :InputValidationResult, "graphql/query/input_validation_result"
+    autoload :VariableValidationError, "graphql/query/variable_validation_error"
+    autoload :ValidationPipeline, "graphql/query/validation_pipeline"
+
     class OperationNameMissingError < GraphQL::ExecutionError
       def initialize(name)
         msg = if name.nil?
@@ -95,21 +97,23 @@ module GraphQL
     # @param root_value [Object] the object used to resolve fields on the root type
     # @param max_depth [Numeric] the maximum number of nested selections allowed for this query (falls back to schema-level value)
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
-    # @param visibility_profile [Symbol]
-    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, static_validator: nil, visibility_profile: nil, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, warden: nil, use_visibility_profile: nil)
+    # @param visibility_profile [Symbol] Another way to assign `context[:visibility_profile]`
+    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, multiplex: nil, validate: true, static_validator: nil, visibility_profile: nil, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, warden: nil, use_visibility_profile: nil)
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
+      @multiplex = multiplex
       @schema = schema
       @context = schema.context_class.new(query: self, values: context)
+      if visibility_profile
+        @context[:visibility_profile] ||= visibility_profile
+      end
 
       if use_visibility_profile.nil?
         use_visibility_profile = warden ? false : schema.use_visibility_profile?
       end
 
-      @visibility_profile = visibility_profile
-
       if use_visibility_profile
-        @visibility_profile = @schema.visibility.profile_for(@context, visibility_profile)
+        @visibility_profile = @schema.visibility.profile_for(@context)
         @warden = Schema::Warden::NullWarden.new(context: @context, schema: @schema)
       else
         @visibility_profile = nil
@@ -125,15 +129,7 @@ module GraphQL
       context_tracers = (context ? context.fetch(:tracers, []) : [])
       @tracers = schema.tracers + context_tracers
 
-      # Support `ctx[:backtrace] = true` for wrapping backtraces
-      if context && context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
-        if schema.trace_class <= GraphQL::Tracing::CallLegacyTracers
-          context_tracers += [GraphQL::Backtrace::Tracer]
-          @tracers << GraphQL::Backtrace::Tracer
-        end
-      end
-
-      if context_tracers.any? && !(schema.trace_class <= GraphQL::Tracing::CallLegacyTracers)
+      if !context_tracers.empty? && !(schema.trace_class <= GraphQL::Tracing::CallLegacyTracers)
         raise ArgumentError, "context[:tracers] are not supported without `trace_with(GraphQL::Tracing::CallLegacyTracers)` in the schema configuration, please add it."
       end
 
@@ -479,7 +475,7 @@ module GraphQL
       @mutation = false
       @subscription = false
       operation_name_error = nil
-      if @operations.any?
+      if !@operations.empty?
         @selected_operation = find_operation(@operations, @operation_name)
         if @selected_operation.nil?
           operation_name_error = GraphQL::Query::OperationNameMissingError.new(@operation_name)

data/lib/graphql/railtie.rb

@@ -1,9 +1,16 @@
 # frozen_string_literal: true
 
 module GraphQL
+  # Support {GraphQL::Parser::Cache} and {GraphQL.eager_load!}
+  #
+  # @example Enable the parser cache with default directory
+  #
+  #   config.graphql.parser_cache = true
+  #
   class Railtie < Rails::Railtie
     config.graphql = ActiveSupport::OrderedOptions.new
     config.graphql.parser_cache = false
+    config.eager_load_namespaces << GraphQL
 
     initializer("graphql.cache") do |app|
       if config.graphql.parser_cache

data/lib/graphql/schema/addition.rb

@@ -40,7 +40,7 @@ module GraphQL
       end
 
       def add_directives_from(owner)
-        if (dir_instances = owner.directives).any?
+        if !(dir_instances = owner.directives).empty?
           dirs = dir_instances.map(&:class)
           @directives.merge(dirs)
           add_type_and_traverse(dirs)

data/lib/graphql/schema/argument.rb

@@ -53,6 +53,7 @@ module GraphQL
       def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, comment: nil, ast_node: nil, default_value: NOT_CONFIGURED, as: nil, from_resolver: false, camelize: true, prepare: nil, owner:, validates: nil, directives: nil, deprecation_reason: nil, replace_null_with_default: false, &definition_block)
         arg_name ||= name
         @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
+        NameValidator.validate!(@name)
         @type_expr = type_expr || type
         @description = desc || description
         @comment = comment
@@ -89,11 +90,8 @@ module GraphQL
         end
 
         if definition_block
-          if definition_block.arity == 1
-            instance_exec(self, &definition_block)
-          else
-            instance_eval(&definition_block)
-          end
+          # `self` will still be self, it will also be the first argument to the block:
+          instance_exec(self, &definition_block)
         end
       end
 
@@ -219,7 +217,7 @@ module GraphQL
       # @api private
       def prepare_value(obj, value, context: nil)
         if type.unwrap.kind.input_object?
-          value = recursively_prepare_input_object(value, type)
+          value = recursively_prepare_input_object(value, type, context)
         end
 
         Schema::Validator.validate!(validators, obj, context, value)
@@ -400,15 +398,16 @@ module GraphQL
 
       private
 
-      def recursively_prepare_input_object(value, type)
+      def recursively_prepare_input_object(value, type, context)
         if type.non_null?
           type = type.of_type
         end
 
         if type.list? && !value.nil?
           inner_type = type.of_type
-          value.map { |v| recursively_prepare_input_object(v, inner_type) }
+          value.map { |v| recursively_prepare_input_object(v, inner_type, context) }
         elsif value.is_a?(GraphQL::Schema::InputObject)
+          value.validate_for(context)
           value.prepare
         else
           value

data/lib/graphql/schema/build_from_definition.rb

@@ -20,8 +20,8 @@ module GraphQL
           from_document(schema_superclass, parser.parse_file(definition_path), **kwargs)
         end
 
-        def from_document(schema_superclass, document, default_resolve:, using: {}, relay: false)
-          Builder.build(schema_superclass, document, default_resolve: default_resolve || {}, relay: relay, using: using)
+        def from_document(schema_superclass, document, default_resolve:, using: {}, base_types: {}, relay: false)
+          Builder.build(schema_superclass, document, default_resolve: default_resolve || {}, relay: relay, using: using, base_types: base_types)
         end
       end
 
@@ -30,9 +30,18 @@ module GraphQL
         include GraphQL::EmptyObjects
         extend self
 
-        def build(schema_superclass, document, default_resolve:, using: {}, relay:)
+        def build(schema_superclass, document, default_resolve:, using: {}, base_types: {}, relay:)
           raise InvalidDocumentError.new('Must provide a document ast.') if !document || !document.is_a?(GraphQL::Language::Nodes::Document)
 
+          base_types = {
+            object: GraphQL::Schema::Object,
+            interface: GraphQL::Schema::Interface,
+            union: GraphQL::Schema::Union,
+            scalar: GraphQL::Schema::Scalar,
+            enum: GraphQL::Schema::Enum,
+            input_object: GraphQL::Schema::InputObject,
+          }.merge!(base_types)
+
           if default_resolve.is_a?(Hash)
             default_resolve = ResolveMap.new(default_resolve)
           end
@@ -53,7 +62,7 @@ module GraphQL
             types[type_name] ||= begin
               defn = document.definitions.find { |d| d.respond_to?(:name) && d.name == type_name }
               if defn
-                build_definition_from_node(defn, directive_type_resolver, default_resolve)
+                build_definition_from_node(defn, directive_type_resolver, default_resolve, base_types)
               elsif (built_in_defn = GraphQL::Schema::BUILT_IN_TYPES[type_name])
                 built_in_defn
               else
@@ -77,14 +86,20 @@ module GraphQL
             case definition
             when GraphQL::Language::Nodes::SchemaDefinition, GraphQL::Language::Nodes::DirectiveDefinition
               nil # already handled
-            when GraphQL::Language::Nodes::SchemaExtension
+            when GraphQL::Language::Nodes::SchemaExtension,
+              GraphQL::Language::Nodes::ScalarTypeExtension,
+              GraphQL::Language::Nodes::ObjectTypeExtension,
+              GraphQL::Language::Nodes::InterfaceTypeExtension,
+              GraphQL::Language::Nodes::UnionTypeExtension,
+              GraphQL::Language::Nodes::EnumTypeExtension,
+              GraphQL::Language::Nodes::InputObjectTypeExtension
               schema_extensions ||= []
               schema_extensions << definition
             else
               # It's possible that this was already loaded by the directives
               prev_type = types[definition.name]
               if prev_type.nil? || prev_type.is_a?(Schema::LateBoundType)
-                types[definition.name] = build_definition_from_node(definition, type_resolver, default_resolve)
+                types[definition.name] = build_definition_from_node(definition, type_resolver, default_resolve, base_types)
               end
             end
           end
@@ -124,6 +139,34 @@ module GraphQL
 
           raise InvalidDocumentError.new('Must provide schema definition with query type or a type named Query.') unless query_root_type
 
+          schema_extensions&.each do |ext|
+            next if ext.is_a?(GraphQL::Language::Nodes::SchemaExtension)
+
+            built_type = types[ext.name]
+
+            case ext
+            when GraphQL::Language::Nodes::ScalarTypeExtension
+              build_directives(built_type, ext, type_resolver)
+            when GraphQL::Language::Nodes::ObjectTypeExtension
+              build_directives(built_type, ext, type_resolver)
+              build_fields(built_type, ext.fields, type_resolver, default_resolve: true)
+              build_interfaces(built_type, ext.interfaces, type_resolver)
+            when GraphQL::Language::Nodes::InterfaceTypeExtension
+              build_directives(built_type, ext, type_resolver)
+              build_fields(built_type, ext.fields, type_resolver, default_resolve: nil)
+              build_interfaces(built_type, ext.interfaces, type_resolver)
+            when GraphQL::Language::Nodes::UnionTypeExtension
+              build_directives(built_type, ext, type_resolver)
+              built_type.possible_types(*ext.types.map { |type_name| type_resolver.call(type_name) })
+            when GraphQL::Language::Nodes::EnumTypeExtension
+              build_directives(built_type, ext, type_resolver)
+              build_values(built_type, ext.values, type_resolver)
+            when GraphQL::Language::Nodes::InputObjectTypeExtension
+              build_directives(built_type, ext, type_resolver)
+              build_arguments(built_type, ext.fields, type_resolver)
+            end
+          end
+
           builder = self
 
           found_types = types.values
@@ -192,8 +235,8 @@ module GraphQL
             end
           end
 
-          if schema_extensions
-            schema_extensions.each do |ext|
+          schema_extensions&.each do |ext|
+            if ext.is_a?(GraphQL::Language::Nodes::SchemaExtension)
               build_directives(schema_class, ext, type_resolver)
             end
           end
@@ -205,20 +248,20 @@ module GraphQL
           raise(GraphQL::RequiredImplementationMissingError, "Generated Schema cannot use Interface or Union types for execution. Implement resolve_type on your resolver.")
         }
 
-        def build_definition_from_node(definition, type_resolver, default_resolve)
+        def build_definition_from_node(definition, type_resolver, default_resolve, base_types)
           case definition
           when GraphQL::Language::Nodes::EnumTypeDefinition
-            build_enum_type(definition, type_resolver)
+            build_enum_type(definition, type_resolver, base_types[:enum])
           when GraphQL::Language::Nodes::ObjectTypeDefinition
-            build_object_type(definition, type_resolver)
+            build_object_type(definition, type_resolver, base_types[:object])
           when GraphQL::Language::Nodes::InterfaceTypeDefinition
-            build_interface_type(definition, type_resolver)
+            build_interface_type(definition, type_resolver, base_types[:interface])
           when GraphQL::Language::Nodes::UnionTypeDefinition
-            build_union_type(definition, type_resolver)
+            build_union_type(definition, type_resolver, base_types[:union])
           when GraphQL::Language::Nodes::ScalarTypeDefinition
-            build_scalar_type(definition, type_resolver, default_resolve: default_resolve)
+            build_scalar_type(definition, type_resolver, base_types[:scalar], default_resolve: default_resolve)
           when GraphQL::Language::Nodes::InputObjectTypeDefinition
-            build_input_object_type(definition, type_resolver)
+            build_input_object_type(definition, type_resolver, base_types[:input_object])
           end
         end
 
@@ -284,22 +327,26 @@ module GraphQL
           end
         end
 
-        def build_enum_type(enum_type_definition, type_resolver)
+        def build_enum_type(enum_type_definition, type_resolver, base_type)
           builder = self
-          Class.new(GraphQL::Schema::Enum) do
+          Class.new(base_type) do
             graphql_name(enum_type_definition.name)
             builder.build_directives(self, enum_type_definition, type_resolver)
             description(enum_type_definition.description)
             ast_node(enum_type_definition)
-            enum_type_definition.values.each do |enum_value_definition|
-              value(enum_value_definition.name,
-                value: enum_value_definition.name,
-                deprecation_reason: builder.build_deprecation_reason(enum_value_definition.directives),
-                description: enum_value_definition.description,
-                directives: builder.prepare_directives(enum_value_definition, type_resolver),
-                ast_node: enum_value_definition,
-              )
-            end
+            builder.build_values(self, enum_type_definition.values, type_resolver)
+          end
+        end
+
+        def build_values(type_class, enum_value_definitions, type_resolver)
+          enum_value_definitions.each do |enum_value_definition|
+            type_class.value(enum_value_definition.name,
+              value: enum_value_definition.name,
+              deprecation_reason: build_deprecation_reason(enum_value_definition.directives),
+              description: enum_value_definition.description,
+              directives: prepare_directives(enum_value_definition, type_resolver),
+              ast_node: enum_value_definition,
+            )
           end
         end
 
@@ -313,9 +360,9 @@ module GraphQL
           reason.value
         end
 
-        def build_scalar_type(scalar_type_definition, type_resolver, default_resolve:)
+        def build_scalar_type(scalar_type_definition, type_resolver, base_type, default_resolve:)
           builder = self
-          Class.new(GraphQL::Schema::Scalar) do
+          Class.new(base_type) do
             graphql_name(scalar_type_definition.name)
             description(scalar_type_definition.description)
             ast_node(scalar_type_definition)
@@ -336,9 +383,9 @@ module GraphQL
           end
         end
 
-        def build_union_type(union_type_definition, type_resolver)
+        def build_union_type(union_type_definition, type_resolver, base_type)
           builder = self
-          Class.new(GraphQL::Schema::Union) do
+          Class.new(base_type) do
             graphql_name(union_type_definition.name)
             description(union_type_definition.description)
             possible_types(*union_type_definition.types.map { |type_name| type_resolver.call(type_name) })
@@ -347,27 +394,28 @@ module GraphQL
           end
         end
 
-        def build_object_type(object_type_definition, type_resolver)
+        def build_object_type(object_type_definition, type_resolver, base_type)
           builder = self
 
-          Class.new(GraphQL::Schema::Object) do
+          Class.new(base_type) do
             graphql_name(object_type_definition.name)
             description(object_type_definition.description)
             ast_node(object_type_definition)
             builder.build_directives(self, object_type_definition, type_resolver)
-
-            object_type_definition.interfaces.each do |interface_name|
-              interface_defn = type_resolver.call(interface_name)
-              implements(interface_defn)
-            end
-
+            builder.build_interfaces(self, object_type_definition.interfaces, type_resolver)
             builder.build_fields(self, object_type_definition.fields, type_resolver, default_resolve: true)
           end
         end
 
-        def build_input_object_type(input_object_type_definition, type_resolver)
+        def build_interfaces(type_class, interface_names, type_resolver)
+          interface_names.each do |interface_name|
+            type_class.implements(type_resolver.call(interface_name))
+          end
+        end
+
+        def build_input_object_type(input_object_type_definition, type_resolver, base_type)
           builder = self
-          Class.new(GraphQL::Schema::InputObject) do
+          Class.new(base_type) do
             graphql_name(input_object_type_definition.name)
             description(input_object_type_definition.description)
             ast_node(input_object_type_definition)
@@ -427,16 +475,13 @@ module GraphQL
           end
         end
 
-        def build_interface_type(interface_type_definition, type_resolver)
+        def build_interface_type(interface_type_definition, type_resolver, base_type)
           builder = self
           Module.new do
-            include GraphQL::Schema::Interface
+            include base_type
             graphql_name(interface_type_definition.name)
             description(interface_type_definition.description)
-            interface_type_definition.interfaces.each do |interface_name|
-              interface_defn = type_resolver.call(interface_name)
-              implements(interface_defn)
-            end
+            builder.build_interfaces(self, interface_type_definition.interfaces, type_resolver)
             ast_node(interface_type_definition)
             builder.build_directives(self, interface_type_definition, type_resolver)
 
@@ -467,17 +512,18 @@ module GraphQL
 
             # Don't do this for interfaces
             if default_resolve
-              owner.class_eval <<-RUBY, __FILE__, __LINE__
-                # frozen_string_literal: true
-                def #{resolve_method_name}(**args)
-                  field_instance = self.class.get_field("#{field_definition.name}")
-                  context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
-                end
-              RUBY
+              define_field_resolve_method(owner, resolve_method_name, field_definition.name)
             end
           end
         end
 
+        def define_field_resolve_method(owner, method_name, field_name)
+          owner.define_method(method_name) { |**args|
+            field_instance = self.class.get_field(field_name)
+            context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
+          }
+        end
+
         def build_resolve_type(lookup_hash, directives, missing_type_handler)
           resolve_type_proc = nil
           resolve_type_proc = ->(ast_node) {

data/lib/graphql/schema/directive/flagged.rb

@@ -37,6 +37,8 @@ module GraphQL
 
         argument :by, [String], "Flags to check for this schema member"
 
+        repeatable(true)
+
         module VisibleByFlag
           def self.included(schema_class)
             schema_class.extend(self)
@@ -45,7 +47,7 @@ module GraphQL
           def visible?(context)
             if dir = self.directives.find { |d| d.is_a?(Flagged) }
               relevant_flags = (f = context[:flags]) && dir.arguments[:by] & f # rubocop:disable Development/ContextIsPassedCop -- definition-related
-              relevant_flags && relevant_flags.any? && super
+              relevant_flags && !relevant_flags.empty? && super
             else
               super
             end

data/lib/graphql/schema/directive.rb

@@ -29,7 +29,7 @@ module GraphQL
         end
 
         def locations(*new_locations)
-          if new_locations.any?
+          if !new_locations.empty?
             new_locations.each do |new_loc|
               if !LOCATIONS.include?(new_loc.to_sym)
                 raise ArgumentError, "#{self} (#{self.graphql_name}) has an invalid directive location: `locations #{new_loc}` "
@@ -99,7 +99,7 @@ module GraphQL
 
         def inherited(subclass)
           super
-          subclass.class_eval do
+          subclass.class_exec do
             @default_graphql_name ||= nil
           end
         end

data/lib/graphql/schema/enum.rb

@@ -61,12 +61,19 @@ module GraphQL
         # @option kwargs [String] :description, the GraphQL description for this value, present in documentation
         # @option kwargs [String] :comment, the GraphQL comment for this value, present in documentation
         # @option kwargs [::Object] :value the translated Ruby value for this object (defaults to `graphql_name`)
+        # @option kwargs [::Object] :value_method, the method name to fetch `graphql_name` (defaults to `graphql_name.downcase`)
         # @option kwargs [String] :deprecation_reason if this object is deprecated, include a message here
+        # @param value_method [Symbol, false] A method to generate for this value, or `false` to skip generation
         # @return [void]
         # @see {Schema::EnumValue} which handles these inputs by default
-        def value(*args, **kwargs, &block)
+        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
@@ -154,6 +161,18 @@ module GraphQL
           end
         end
 
+        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
+
         def kind
           GraphQL::TypeKinds::ENUM
         end
@@ -215,6 +234,7 @@ module GraphQL
             # because they would end up with names like `#<Class0x1234>::UnresolvedValueError` which messes up bug trackers
             child_class.const_set(:UnresolvedValueError, Class.new(Schema::Enum::UnresolvedValueError))
           end
+          child_class.class_exec { @value_methods = nil }
           super
         end
 
@@ -223,6 +243,21 @@ module GraphQL
         def own_values
           @own_values ||= {}
         end
+
+        def generate_value_method(value, configured_value_method)
+          return if configured_value_method == false
+
+          value_method_name = configured_value_method || value.graphql_name.downcase
+
+          if respond_to?(value_method_name.to_sym)
+            warn "Failed to define value method for :#{value_method_name}, because " \
+              "#{value.owner.name || value.owner.graphql_name} already responds to that method. Use `value_method:` to override the method name " \
+              "or `value_method: false` to disable Enum value method generation."
+            return
+          end
+
+          define_singleton_method(value_method_name) { value.graphql_name }
+        end
       end
 
       enum_value_class(GraphQL::Schema::EnumValue)

data/lib/graphql/schema/enum_value.rb

@@ -48,7 +48,7 @@ module GraphQL
         end
 
         if block_given?
-          instance_eval(&block)
+          instance_exec(self, &block)
         end
       end
 

data/lib/graphql/schema/field/scope_extension.rb

@@ -12,7 +12,7 @@ module GraphQL
             if ret_type.respond_to?(:scope_items)
               scoped_items = ret_type.scope_items(value, context)
               if !scoped_items.equal?(value) && !ret_type.reauthorize_scoped_objects
-                if (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
+                if (current_runtime_state = Fiber[:__graphql_runtime_info]) &&
                     (query_runtime_state = current_runtime_state[context.query])
                   query_runtime_state.was_authorized_by_scope_items = true
                 end