graphql-client 0.18.0 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82b89599e02036868b2249fbd3ac2aeb89b6043b19040bdaeaf66f31b5f1b28e
-  data.tar.gz: 2e168f61452bd5041aa01dce3a09c99959b629afeb2880ca629d1034f22fb0d9
+  metadata.gz: 9ab40176a982910f10885b2c56a3d3ad867937ee4f824a4af06e75993236f1f0
+  data.tar.gz: 291c8ed2700b79bf5b41c2f799899dac7316d000b04e9cdeaae87cea0519e411
 SHA512:
-  metadata.gz: 3f14f21ff57e8dc29dbef6e5fb2ee6d2fb552075986ef57c8f89a3d7ce5b2faa8e2965b20a5b8f7735394b3ee13cdc8e55923bda0dd02fa8625f7e2b824dab7b
-  data.tar.gz: ee04576697c258bdc3959366d0cccef720e24eb2358ecbb28c020d912c5b241ac7ba195a8240656c6f825109c23a321ef2449892b4d893e29802c03b6580f557
+  metadata.gz: 8a5a4cc5b341c302c1c2b20a12d10b59907a34ca9d50871e1e48c2984dbdf8562eb40eab123f6474eb96024ca6eeaa08f4ebf3c043dacb0e46f3211a3c00b921
+  data.tar.gz: 6cba9520177116c4d332578bee01f98a42adff2cba51ca123f7083a6980826725db7f090fcd8c37debdb3c654b7cac4b27b21e7f1f86d6a76b4e8676340d8f08

data/README.md

@@ -1,4 +1,4 @@
-# graphql-client [![Gem Version](https://badge.fury.io/rb/graphql-client.svg)](https://badge.fury.io/rb/graphql-client) [![CI](https://github.com/github/graphql-client/workflows/CI/badge.svg)](https://github.com/github/graphql-client/actions?query=workflow)
+# graphql-client [![Gem Version](https://badge.fury.io/rb/graphql-client.svg)](https://badge.fury.io/rb/graphql-client) [![CI](https://github.com/github-community-projects/graphql-client/workflows/CI/badge.svg)](https://github.com/github-community-projects/graphql-client/actions?query=workflow)
 
 GraphQL Client is a Ruby library for declaring, composing and executing GraphQL queries.
 

data/lib/graphql/client/collocated_enforcement.rb

@@ -26,7 +26,7 @@ module GraphQL
         return yield if Thread.current[:query_result_caller_location_ignore]
 
         if (location.path != path) && !(WHITELISTED_GEM_NAMES.any? { |g| location.path.include?("gems/#{g}") })
-          error = NonCollocatedCallerError.new("#{method} was called outside of '#{path}' https://git.io/v1syX")
+          error = NonCollocatedCallerError.new("#{method} was called outside of '#{path}' https://github.com/github-community-projects/graphql-client/blob/master/guides/collocated-call-sites.md")
           error.set_backtrace(caller(2))
           raise error
         end

data/lib/graphql/client/definition.rb

@@ -147,41 +147,58 @@ module GraphQL
       # Internal: Nodes AST indexes.
       def indexes
         @indexes ||= begin
-          visitor = GraphQL::Language::Visitor.new(document)
-          definitions = index_node_definitions(visitor)
-          spreads = index_spreads(visitor)
+          visitor = DefinitionVisitor.new(document)
           visitor.visit
-          { definitions: definitions, spreads: spreads }
+          { definitions: visitor.definitions, spreads: visitor.spreads }
         end
       end
 
-      private
+      class DefinitionVisitor < GraphQL::Language::Visitor
+        attr_reader :spreads, :definitions
 
-        def cast_object(obj)
-          if obj.class.is_a?(GraphQL::Client::Schema::ObjectType)
-            unless obj._spreads.include?(definition_node.name)
-              raise TypeError, "#{definition_node.name} is not included in #{obj.source_definition.name}"
-            end
-            schema_class.cast(obj.to_h, obj.errors)
-          else
-            raise TypeError, "unexpected #{obj.class}"
-          end
+        def initialize(doc)
+          super
+          @spreads = {}
+          @definitions = {}
+          @current_definition = nil
         end
 
-        EMPTY_SET = Set.new.freeze
+        def on_field(node, parent)
+          @definitions[node] = @current_definition
+          @spreads[node] = get_spreads(node)
+          super
+        end
 
-        def index_spreads(visitor)
-          spreads = {}
-          on_node = ->(node, _parent) do
-            node_spreads = flatten_spreads(node).map(&:name)
-            spreads[node] = node_spreads.empty? ? EMPTY_SET : Set.new(node_spreads).freeze
-          end
+        def on_fragment_definition(node, parent)
+          @current_definition = node
+          @definitions[node] = @current_definition
+          @spreads[node] = get_spreads(node)
+          super
+        ensure
+          @current_definition = nil
+        end
 
-          visitor[GraphQL::Language::Nodes::Field] << on_node
-          visitor[GraphQL::Language::Nodes::FragmentDefinition] << on_node
-          visitor[GraphQL::Language::Nodes::OperationDefinition] << on_node
+        def on_operation_definition(node, parent)
+          @current_definition = node
+          @definitions[node] = @current_definition
+          @spreads[node] = get_spreads(node)
+          super
+        ensure
+          @current_definition = nil
+        end
 
-          spreads
+        def on_inline_fragment(node, parent)
+          @definitions[node] = @current_definition
+          super
+        end
+
+        private
+
+        EMPTY_SET = Set.new.freeze
+
+        def get_spreads(node)
+          node_spreads = flatten_spreads(node).map(&:name)
+          node_spreads.empty? ? EMPTY_SET : Set.new(node_spreads).freeze
         end
 
         def flatten_spreads(node)
@@ -198,25 +215,20 @@ module GraphQL
           end
           spreads
         end
+      end
 
-        def index_node_definitions(visitor)
-          current_definition = nil
-          enter_definition = ->(node, _parent) { current_definition = node }
-          leave_definition = ->(node, _parent) { current_definition = nil }
-
-          visitor[GraphQL::Language::Nodes::FragmentDefinition].enter << enter_definition
-          visitor[GraphQL::Language::Nodes::FragmentDefinition].leave << leave_definition
-          visitor[GraphQL::Language::Nodes::OperationDefinition].enter << enter_definition
-          visitor[GraphQL::Language::Nodes::OperationDefinition].leave << leave_definition
-
-          definitions = {}
-          on_node = ->(node, _parent) { definitions[node] = current_definition }
-          visitor[GraphQL::Language::Nodes::Field] << on_node
-          visitor[GraphQL::Language::Nodes::FragmentDefinition] << on_node
-          visitor[GraphQL::Language::Nodes::InlineFragment] << on_node
-          visitor[GraphQL::Language::Nodes::OperationDefinition] << on_node
-          definitions
+      private
+
+      def cast_object(obj)
+        if obj.class.is_a?(GraphQL::Client::Schema::ObjectType)
+          unless obj._spreads.include?(definition_node.name)
+            raise TypeError, "#{definition_node.name} is not included in #{obj.source_definition.name}"
+          end
+          schema_class.cast(obj.to_h, obj.errors)
+        else
+          raise TypeError, "unexpected #{obj.class}"
         end
+      end
     end
   end
 end

data/lib/graphql/client/definition_variables.rb

@@ -24,26 +24,33 @@ module GraphQL
 
         sliced_document = GraphQL::Language::DefinitionSlice.slice(document, definition_name)
 
-        visitor = GraphQL::Language::Visitor.new(sliced_document)
-        type_stack = GraphQL::StaticValidation::TypeStack.new(schema, visitor)
+        visitor = VariablesVisitor.new(sliced_document, schema: schema)
+        visitor.visit
+        visitor.variables
+      end
+
+      class VariablesVisitor < GraphQL::Language::Visitor
+        prepend GraphQL::Client::TypeStack
+
+        def initialize(*_args, **_kwargs)
+          super
+          @variables = {}
+        end
 
-        variables = {}
+        attr_reader :variables
 
-        visitor[GraphQL::Language::Nodes::VariableIdentifier] << ->(node, parent) do
-          if definition = type_stack.argument_definitions.last
-            existing_type = variables[node.name.to_sym]
+        def on_variable_identifier(node, parent)
+          if definition = @argument_definitions.last
+            existing_type = @variables[node.name.to_sym]
 
             if existing_type && existing_type.unwrap != definition.type.unwrap
               raise GraphQL::Client::ValidationError, "$#{node.name} was already declared as #{existing_type.unwrap}, but was #{definition.type.unwrap}"
             elsif !(existing_type && existing_type.kind.non_null?)
-              variables[node.name.to_sym] = definition.type
+              @variables[node.name.to_sym] = definition.type
             end
           end
+          super
         end
-
-        visitor.visit
-
-        variables
       end
 
       # Internal: Detect all variables used in a given operation or fragment

data/lib/graphql/client/document_types.rb

@@ -1,10 +1,41 @@
 # frozen_string_literal: true
 require "graphql"
+require "graphql/client/type_stack"
 
 module GraphQL
   class Client
     # Internal: Use schema to detect definition and field types.
     module DocumentTypes
+      class AnalyzeTypesVisitor < GraphQL::Language::Visitor
+        prepend GraphQL::Client::TypeStack
+        attr_reader :fields
+
+        def initialize(*a, **kw)
+          @fields = {}
+          super
+        end
+
+        def on_operation_definition(node, _parent)
+          @fields[node] = @object_types.last
+          super
+        end
+
+        def on_fragment_definition(node, _parent)
+          @fields[node] = @object_types.last
+          super
+        end
+
+        def on_inline_fragment(node, _parent)
+          @fields[node] = @object_types.last
+          super
+        end
+
+        def on_field(node, _parent)
+          @fields[node] = @field_definitions.last.type
+          super
+        end
+      end
+
       # Internal: Detect all types used in a given document
       #
       # schema - A GraphQL::Schema
@@ -20,32 +51,15 @@ module GraphQL
           raise TypeError, "expected schema to be a GraphQL::Language::Nodes::Document, but was #{document.class}"
         end
 
-        visitor = GraphQL::Language::Visitor.new(document)
-        type_stack = GraphQL::StaticValidation::TypeStack.new(schema, visitor)
-
-        fields = {}
-
-        visitor[GraphQL::Language::Nodes::OperationDefinition] << ->(node, _parent) do
-          fields[node] = type_stack.object_types.last
-        end
-        visitor[GraphQL::Language::Nodes::FragmentDefinition] << ->(node, _parent) do
-          fields[node] = type_stack.object_types.last
-        end
-        visitor[GraphQL::Language::Nodes::InlineFragment] << ->(node, _parent) do
-          fields[node] = type_stack.object_types.last
-        end
-        visitor[GraphQL::Language::Nodes::Field] << ->(node, _parent) do
-          fields[node] = type_stack.field_definitions.last.type
-        end
+        visitor = AnalyzeTypesVisitor.new(document, schema: schema)
         visitor.visit
-
-        fields
+        visitor.fields
       rescue StandardError => err
         if err.is_a?(TypeError)
           raise
         end
         # FIXME: TypeStack my crash on invalid documents
-        fields
+        visitor.fields
       end
     end
   end

data/lib/graphql/client/errors.rb

@@ -21,7 +21,7 @@ module GraphQL
         errors.each do |error|
           path = ["data"]
           current = data
-          error.fetch("path", []).each do |key|
+          error["path"].to_a.each do |key|
             break unless current
             path << key
             current = current[key]

data/lib/graphql/client/log_subscriber.rb

@@ -16,11 +16,18 @@ module GraphQL
     #   GraphQL::Client::LogSubscriber.attach_to :graphql
     #
     class LogSubscriber < ActiveSupport::LogSubscriber
+      SHOULD_USE_KWARGS = private_instance_methods.include?(:mode_from)
+
       def query(event)
         logger.info do
           name = event.payload[:operation_name].gsub("__", "::")
           type = event.payload[:operation_type].upcase
-          color("#{name} #{type} (#{event.duration.round(1)}ms)", nil, true)
+
+          if SHOULD_USE_KWARGS
+            color("#{name} #{type} (#{event.duration.round(1)}ms)", nil, bold: true)
+          else
+            color("#{name} #{type} (#{event.duration.round(1)}ms)", nil, true)
+          end
         end
 
         logger.debug do
@@ -32,7 +39,12 @@ module GraphQL
         logger.error do
           name = event.payload[:operation_name].gsub("__", "::")
           message = event.payload[:message]
-          color("#{name} ERROR: #{message}", nil, true)
+
+          if SHOULD_USE_KWARGS
+            color("#{name} ERROR: #{message}", nil, bold: true)
+          else
+            color("#{name} ERROR: #{message}", nil, true)
+          end
         end
       end
     end

data/lib/graphql/client/response.rb

@@ -12,6 +12,7 @@ module GraphQL
       # Returns Hash.
       attr_reader :original_hash
       alias_method :to_h, :original_hash
+      alias_method :to_hash, :original_hash
 
       # Public: Wrapped ObjectType of data returned from the server.
       #

data/lib/graphql/client/schema/enum_type.rb

@@ -16,6 +16,10 @@ module GraphQL
             @enum = enum
           end
 
+          def unknown_enum_value?
+            false
+          end
+
           def respond_to_missing?(method_name, include_private = false)
             if method_name[-1] == "?" && @enum.include?(method_name[0..-2])
               true
@@ -37,6 +41,12 @@ module GraphQL
           end
         end
 
+        class UnexpectedEnumValue < String
+          def unknown_enum_value?
+            true
+          end
+        end
+
         # Internal: Construct enum wrapper from another GraphQL::EnumType.
         #
         # type - GraphQL::EnumType instance
@@ -78,8 +88,13 @@ module GraphQL
         def cast(value, _errors = nil)
           case value
           when String
-            raise Error, "unexpected enum value #{value}" unless @values.key?(value)
-            @values[value]
+            if @values.key?(value)
+              @values[value]
+            elsif schema_module.raise_on_unknown_enum_value
+              raise Error, "unexpected enum value #{value}"
+            else
+              UnexpectedEnumValue.new(value).freeze
+            end
           when NilClass
             value
           else

data/lib/graphql/client/schema/object_type.rb

@@ -3,7 +3,6 @@ require "active_support/inflector"
 require "graphql/client/error"
 require "graphql/client/errors"
 require "graphql/client/schema/base_type"
-require "graphql/client/schema/possible_types"
 
 module GraphQL
   class Client
@@ -132,13 +131,13 @@ module GraphQL
           case selected_ast_node
           when GraphQL::Language::Nodes::InlineFragment
             continue_selection = if selected_ast_node.type.nil?
-              true
-            else
-              type_condition = definition.client.get_type(selected_ast_node.type.name)
-              applicable_types = definition.client.possible_types(type_condition)
-              # continue if this object type is one of the types matching the fragment condition
-              applicable_types.include?(type)
-            end
+                                   true
+                                 else
+                                   type_condition = definition.client.get_type(selected_ast_node.type.name)
+                                   applicable_types = definition.client.possible_types(type_condition)
+                                   # continue if this object type is one of the types matching the fragment condition
+                                   applicable_types.include?(type)
+                                 end
 
             if continue_selection
               selected_ast_node.selections.each do |next_selected_ast_node|
@@ -192,6 +191,7 @@ module GraphQL
         def to_h
           @data
         end
+        alias :to_hash :to_h
 
         def _definer
           @definer
@@ -255,13 +255,13 @@ module GraphQL
               end
 
               unless field
-                raise UnimplementedFieldError, "undefined field `#{e.name}' on #{type.graphql_name} type. https://git.io/v1y3m"
+                raise UnimplementedFieldError, "undefined field `#{e.name}' on #{type.graphql_name} type. https://github.com/github-community-projects/graphql-client/blob/master/guides/unimplemented-field-error.md"
               end
 
               if @data.key?(field.name)
-                raise ImplicitlyFetchedFieldError, "implicitly fetched field `#{field.name}' on #{type} type. https://git.io/v1yGL"
+                raise ImplicitlyFetchedFieldError, "implicitly fetched field `#{field.name}' on #{type} type. https://github.com/github-community-projects/graphql-client/blob/master/guides/implicitly-fetched-field-error.md"
               else
-                raise UnfetchedFieldError, "unfetched field `#{field.name}' on #{type} type. https://git.io/v1y3U"
+                raise UnfetchedFieldError, "unfetched field `#{field.name}' on #{type} type. https://github.com/github-community-projects/graphql-client/blob/master/guides/unfetched-field-error.md"
               end
             end
           end

data/lib/graphql/client/schema.rb

@@ -43,7 +43,7 @@ module GraphQL
         def set_class(type_name, klass)
           class_name = normalize_type_name(type_name)
 
-          if constants.include?(class_name.to_sym)
+          if const_defined?(class_name, false)
             raise ArgumentError,
               "Can't define #{class_name} to represent type #{type_name} " \
               "because it's already defined"
@@ -66,9 +66,10 @@ module GraphQL
         end
       end
 
-      def self.generate(schema)
+      def self.generate(schema, raise_on_unknown_enum_value: true)
         mod = Module.new
         mod.extend ClassMethods
+        mod.define_singleton_method(:raise_on_unknown_enum_value) { raise_on_unknown_enum_value }
 
         cache = {}
         schema.types.each do |name, type|

data/lib/graphql/client/type_stack.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+module GraphQL
+  class Client
+    module TypeStack
+      # @return [GraphQL::Schema] the schema whose types are present in this document
+      attr_reader :schema
+
+      # When it enters an object (starting with query or mutation root), it's pushed on this stack.
+      # When it exits, it's popped off.
+      # @return [Array<GraphQL::ObjectType, GraphQL::Union, GraphQL::Interface>]
+      attr_reader :object_types
+
+      # When it enters a field, it's pushed on this stack (useful for nested fields, args).
+      # When it exits, it's popped off.
+      # @return [Array<GraphQL::Field>] fields which have been entered
+      attr_reader :field_definitions
+
+      # Directives are pushed on, then popped off while traversing the tree
+      # @return [Array<GraphQL::Node::Directive>] directives which have been entered
+      attr_reader :directive_definitions
+
+      # @return [Array<GraphQL::Node::Argument>] arguments which have been entered
+      attr_reader :argument_definitions
+
+      # @return [Array<String>] fields which have been entered (by their AST name)
+      attr_reader :path
+
+      # @param schema [GraphQL::Schema] the schema whose types to use when climbing this document
+      # @param visitor [GraphQL::Language::Visitor] a visitor to follow & watch the types
+      def initialize(document, schema:, **rest)
+        @schema = schema
+        @object_types = []
+        @field_definitions = []
+        @directive_definitions = []
+        @argument_definitions = []
+        @path = []
+        super(document, **rest)
+      end
+
+      def on_directive(node, parent)
+        directive_defn = @schema.directives[node.name]
+        @directive_definitions.push(directive_defn)
+        super(node, parent)
+      ensure
+        @directive_definitions.pop
+      end
+
+      def on_field(node, parent)
+        parent_type = @object_types.last
+        parent_type = parent_type.unwrap
+
+        field_definition = @schema.get_field(parent_type, node.name)
+        @field_definitions.push(field_definition)
+        if !field_definition.nil?
+          next_object_type = field_definition.type
+          @object_types.push(next_object_type)
+        else
+          @object_types.push(nil)
+        end
+        @path.push(node.alias || node.name)
+        super(node, parent)
+      ensure
+        @field_definitions.pop
+        @object_types.pop
+        @path.pop
+      end
+
+      def on_argument(node, parent)
+        if @argument_definitions.last
+          arg_type = @argument_definitions.last.type.unwrap
+          if arg_type.kind.input_object?
+            argument_defn = arg_type.arguments[node.name]
+          else
+            argument_defn = nil
+          end
+        elsif @directive_definitions.last
+          argument_defn = @directive_definitions.last.arguments[node.name]
+        elsif @field_definitions.last
+          argument_defn = @field_definitions.last.arguments[node.name]
+        else
+          argument_defn = nil
+        end
+        @argument_definitions.push(argument_defn)
+        @path.push(node.name)
+        super(node, parent)
+      ensure
+        @argument_definitions.pop
+        @path.pop
+      end
+
+      def on_operation_definition(node, parent)
+        # eg, QueryType, MutationType
+        object_type = @schema.root_type_for_operation(node.operation_type)
+        @object_types.push(object_type)
+        @path.push("#{node.operation_type}#{node.name ? " #{node.name}" : ""}")
+        super(node, parent)
+      ensure
+        @object_types.pop
+        @path.pop
+      end
+
+      def on_inline_fragment(node, parent)
+        object_type = if node.type
+                        @schema.get_type(node.type.name)
+                      else
+                        @object_types.last
+                      end
+        if !object_type.nil?
+          object_type = object_type.unwrap
+        end
+        @object_types.push(object_type)
+        @path.push("...#{node.type ? " on #{node.type.to_query_string}" : ""}")
+        super(node, parent)
+      ensure
+        @object_types.pop
+        @path.pop
+      end
+
+      def on_fragment_definition(node, parent)
+        object_type = if node.type
+                        @schema.get_type(node.type.name)
+                      else
+                        @object_types.last
+                      end
+        if !object_type.nil?
+          object_type = object_type.unwrap
+        end
+        @object_types.push(object_type)
+        @path.push("fragment #{node.name}")
+        super(node, parent)
+      ensure
+        @object_types.pop
+        @path.pop
+      end
+
+      def on_fragment_spread(node, parent)
+        @path.push("... #{node.name}")
+        super(node, parent)
+      ensure
+        @path.pop
+      end
+    end
+  end
+end

data/lib/graphql/client.rb

@@ -2,6 +2,7 @@
 require "active_support/inflector"
 require "active_support/notifications"
 require "graphql"
+require "graphql/client/type_stack"
 require "graphql/client/collocated_enforcement"
 require "graphql/client/definition_variables"
 require "graphql/client/definition"
@@ -90,7 +91,7 @@ module GraphQL
       result
     end
 
-    def initialize(schema:, execute: nil, enforce_collocated_callers: false)
+    def initialize(schema:, execute: nil, enforce_collocated_callers: false, raise_on_unknown_enum_value: true)
       @schema = self.class.load_schema(schema)
       @execute = execute
       @document = GraphQL::Language::Nodes::Document.new(definitions: [])
@@ -99,8 +100,13 @@ module GraphQL
       @enforce_collocated_callers = enforce_collocated_callers
       if schema.is_a?(Class)
         @possible_types = schema.possible_types
+        key, _types = @possible_types.first
+        # GraphQL-Ruby 2.3.5+ has classes here instead of strings
+        if key.is_a?(Module)
+          @possible_types = @possible_types.transform_keys(&:graphql_name)
+        end
       end
-      @types = Schema.generate(@schema)
+      @types = Schema.generate(@schema, raise_on_unknown_enum_value: raise_on_unknown_enum_value)
     end
 
     # A cache of the schema's merged possible types
@@ -337,7 +343,7 @@ module GraphQL
       end
 
       if allow_dynamic_queries == false && definition.name.nil?
-        raise DynamicQueryError, "expected definition to be assigned to a static constant https://git.io/vXXSE"
+        raise DynamicQueryError, "expected definition to be assigned to a static constant https://github.com/github-community-projects/graphql-client/blob/master/guides/dynamic-query-error.md"
       end
 
       variables = deep_stringify_keys(variables)
@@ -402,7 +408,6 @@ module GraphQL
 
       doc.definitions.map do |node|
         deps = Set.new
-        definitions = document_dependencies.definitions.map { |x| [x.name, x] }.to_h
 
         queue = [node.name]
         while name = queue.shift
@@ -425,12 +430,26 @@ module GraphQL
       end.to_h
     end
 
+    class GatherNamesVisitor < GraphQL::Language::Visitor
+      def initialize(node)
+        @names = []
+        super
+      end
+
+      attr_reader :names
+
+      def on_fragment_spread(node, parent)
+        @names << node.name
+        super
+      end
+    end
+
     def find_definition_dependencies(node)
-      names = []
-      visitor = Language::Visitor.new(node)
-      visitor[Language::Nodes::FragmentSpread] << -> (node, parent) { names << node.name }
+      visitor = GatherNamesVisitor.new(node)
       visitor.visit
-      names.uniq
+      names = visitor.names
+      names.uniq!
+      names
     end
 
     def deep_freeze_json_object(obj)

data/lib/rubocop/cop/graphql/overfetch.rb

@@ -21,19 +21,12 @@ module RuboCop
           query, = ::GraphQL::Client::ViewModule.extract_graphql_section(erb)
           return unless query
 
-          aliases = {}
-          fields = {}
-          ranges = {}
-
           # TODO: Use GraphQL client parser
           document = ::GraphQL.parse(query.gsub(/::/, "__"))
-
-          visitor = ::GraphQL::Language::Visitor.new(document)
-          visitor[::GraphQL::Language::Nodes::Field] << ->(node, _parent) do
-            name = node.alias || node.name
-            fields[name] ||= 0
-            field_aliases(name).each { |n| (aliases[n] ||= []) << name }
-            ranges[name] ||= source_range(processed_source.buffer, node.line, 0)
+          visitor = OverfetchVisitor.new(document) do |line_num|
+            # `source_range` is private to this object,
+            # so yield back out to it to get this info:
+            source_range(processed_source.buffer, line_num, 0)
           end
           visitor.visit
 
@@ -41,30 +34,53 @@ module RuboCop
             method_names = method_names_for(*node)
 
             method_names.each do |method_name|
-              aliases.fetch(method_name, []).each do |field_name|
-                fields[field_name] += 1
+              visitor.aliases.fetch(method_name, []).each do |field_name|
+                visitor.fields[field_name] += 1
               end
             end
           end
 
-          fields.each do |field, count|
+          visitor.fields.each do |field, count|
             next if count > 0
-            add_offense(nil, location: ranges[field], message: "GraphQL field '#{field}' query but was not used in template.")
+            add_offense(nil, location: visitor.ranges[field], message: "GraphQL field '#{field}' query but was not used in template.")
           end
         end
 
-        def field_aliases(name)
-          names = Set.new
+        class OverfetchVisitor < ::GraphQL::Language::Visitor
+          def initialize(doc, &range_for_line)
+            super(doc)
+            @range_for_line = range_for_line
+            @fields = {}
+            @aliases = {}
+            @ranges = {}
+          end
+
+          attr_reader :fields, :aliases, :ranges
+
+          def on_field(node, parent)
+            name = node.alias || node.name
+            fields[name] ||= 0
+            field_aliases(name).each { |n| (aliases[n] ||= []) << name }
+            ranges[name] ||= @range_for_line.call(node.line)
+            super
+          end
 
-          names << name
-          names << "#{name}?"
+          private
 
-          names << underscore_name = ActiveSupport::Inflector.underscore(name)
-          names << "#{underscore_name}?"
+          def field_aliases(name)
+            names = Set.new
 
-          names
+            names << name
+            names << "#{name}?"
+
+            names << underscore_name = ActiveSupport::Inflector.underscore(name)
+            names << "#{underscore_name}?"
+
+            names
+          end
         end
 
+
         def method_names_for(*node)
           receiver, method_name, *_args = node
           method_names = []

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-client
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.23.0
 platform: ruby
 authors:
 - GitHub
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-02 00:00:00.000000000 Z
+date: 2024-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.13.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.13.0
 - !ruby/object:Gem::Dependency
   name: actionpack
   requirement: !ruby/object:Gem::Requirement
@@ -100,48 +100,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.2'
+        version: 13.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.2'
+        version: 13.1.0
 - !ruby/object:Gem::Dependency
   name: rubocop-github
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.10'
-    - - "<="
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.16.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.10'
-    - - "<="
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.16.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.55'
+        version: 1.64.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.55'
+        version: 1.64.1
 description: A Ruby library for declaring, composing and executing GraphQL queries
 email: engineering@github.com
 executables: []
@@ -182,13 +176,15 @@ files:
 - lib/graphql/client/schema/scalar_type.rb
 - lib/graphql/client/schema/skip_directive.rb
 - lib/graphql/client/schema/union_type.rb
+- lib/graphql/client/type_stack.rb
 - lib/graphql/client/view_module.rb
 - lib/rubocop/cop/graphql/heredoc.rb
 - lib/rubocop/cop/graphql/overfetch.rb
-homepage: https://github.com/github/graphql-client
+homepage: https://github.com/github-community-projects/graphql-client
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -204,7 +200,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.9
+rubygems_version: 3.5.9
 signing_key: 
 specification_version: 4
 summary: GraphQL Client