graphql-client 0.16.0 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6810301cbdd84362dc4b8584e24deec3aec4248f4471734748cf1a33feaa5232
-  data.tar.gz: bb68c48d70c276c0443da6620506b37dbe152e20fb931a2ecf3a0cba45050f96
+  metadata.gz: 3d469dea9c19c2b7b70f57554d66dab3374c496ef09bc013d9464509faac1243
+  data.tar.gz: 7fdc9c16119e205cc1e200ee4fc5d882776bbd94c1294dc075963428d7d9f7e4
 SHA512:
-  metadata.gz: 6b7f114d4330ae5168669d7a663a0afdbd508ba056aa252a206efca9071f558c8749ecfd809ca0677ab9e3a5e95cc90eec3a6bcc2e4020875aab6621d9059dd8
-  data.tar.gz: b1a24192dc4ee004ae6d546d4d724d0c49da4a17a4fb86a1a7e81d1aefbe16618f32ed27a63a8c2297bd4074ec8dd91794ab057d3826d08ccfefe21d689e7e76
+  metadata.gz: 51ad31a0fd1faf1275037177e7b22f29f597ab9c03868831422de07f563a1c2911a32372832f45053c2430648a267067a721b66df5697fbc1e8735fefddf78b1
+  data.tar.gz: 6162d16ba9cefdd82356c89fd799744bcb0777716c0a379c403f519c4aa5fb1c1d2a0a15955852f31d76326fcb6ceebb24fc861c85d211078e5b492bbbc95e0f

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) [![Build Status](https://travis-ci.org/github/graphql-client.svg?branch=master)](https://travis-ci.org/github/graphql-client)
+# 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 is a Ruby library for declaring, composing and executing GraphQL queries.
 

data/lib/graphql/client/collocated_enforcement.rb

@@ -12,6 +12,8 @@ module GraphQL
 
     # Enforcements collocated object access best practices.
     module CollocatedEnforcement
+      extend self
+
       # Public: Ignore collocated caller enforcement for the scope of the block.
       def allow_noncollocated_callers
         Thread.current[:query_result_caller_location_ignore] = true
@@ -20,6 +22,23 @@ module GraphQL
         Thread.current[:query_result_caller_location_ignore] = nil
       end
 
+      def verify_collocated_path(location, path, method = "method")
+        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.set_backtrace(caller(2))
+          raise error
+        end
+
+        begin
+          Thread.current[:query_result_caller_location_ignore] = true
+          yield
+        ensure
+          Thread.current[:query_result_caller_location_ignore] = nil
+        end
+      end
+
       # Internal: Decorate method with collocated caller enforcement.
       #
       # mod - Target Module/Class
@@ -31,21 +50,9 @@ module GraphQL
         mod.prepend(Module.new do
           methods.each do |method|
             define_method(method) do |*args, &block|
-              return super(*args, &block) if Thread.current[:query_result_caller_location_ignore]
-
-              locations = caller_locations(1, 1)
-
-              if (locations.first.path != path) && !(caller_locations.any? { |cl| WHITELISTED_GEM_NAMES.any? { |g| cl.path.include?("gems/#{g}") } })
-                error = NonCollocatedCallerError.new("#{method} was called outside of '#{path}' https://git.io/v1syX")
-                error.set_backtrace(caller(1))
-                raise error
-              end
-
-              begin
-                Thread.current[:query_result_caller_location_ignore] = true
+              location = caller_locations(1, 1)[0]
+              CollocatedEnforcement.verify_collocated_path(location, path, method) do
                 super(*args, &block)
-              ensure
-                Thread.current[:query_result_caller_location_ignore] = nil
               end
             end
           end

data/lib/graphql/client/definition.rb

@@ -115,9 +115,24 @@ module GraphQL
           else
             cast_object(obj)
           end
+        when GraphQL::Client::Schema::ObjectType::WithDefinition
+          case obj
+          when schema_class.klass
+            if obj._definer == schema_class
+              obj
+            else
+              cast_object(obj)
+            end
+          when nil
+            nil
+          when Hash
+            schema_class.new(obj, errors)
+          else
+            cast_object(obj)
+          end
         when GraphQL::Client::Schema::ObjectType
           case obj
-          when NilClass, schema_class
+          when nil, schema_class
             obj
           when Hash
             schema_class.new(obj, errors)
@@ -132,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.class._spreads.include?(definition_node.name)
-              raise TypeError, "#{definition_node.name} is not included in #{obj.class.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)
@@ -183,25 +215,20 @@ module GraphQL
           end
           spreads
         end
+      end
+
+      private
 
-        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
+      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/http.rb

@@ -7,7 +7,7 @@ module GraphQL
   class Client
     # Public: Basic HTTP network adapter.
     #
-    #   GraphQL::Client::Client.new(
+    #   GraphQL::Client.new(
     #     execute: GraphQL::Client::HTTP.new("http://graphql-swapi.parseapp.com/")
     #   )
     #

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

@@ -21,7 +21,7 @@ module GraphQL
         end
 
         def define_class(definition, ast_nodes)
-          possible_type_names = definition.client.schema.possible_types(type).map(&:graphql_name)
+          possible_type_names = definition.client.possible_types(type).map(&:graphql_name)
           possible_types = possible_type_names.map { |concrete_type_name|
             schema_module.get_class(concrete_type_name).define_class(definition, ast_nodes)
           }

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

@@ -16,6 +16,53 @@ module GraphQL
 
             define_singleton_method(:type) { type }
             define_singleton_method(:fields) { fields }
+
+            const_set(:READERS, {})
+            const_set(:PREDICATES, {})
+          end
+        end
+
+        class WithDefinition
+          include BaseType
+          include ObjectType
+
+          EMPTY_SET = Set.new.freeze
+
+          attr_reader :klass, :defined_fields, :definition
+
+          def type
+            @klass.type
+          end
+
+          def fields
+            @klass.fields
+          end
+
+          def spreads
+            if defined?(@spreads)
+              @spreads
+            else
+              EMPTY_SET
+            end
+          end
+
+          def initialize(klass, defined_fields, definition, spreads)
+            @klass = klass
+            @defined_fields = defined_fields.map do |k, v|
+              [-k.to_s, v]
+            end.to_h
+            @definition = definition
+            @spreads = spreads unless spreads.empty?
+
+            @defined_fields.keys.each do |attr|
+              name = ActiveSupport::Inflector.underscore(attr)
+              @klass::READERS[:"#{name}"] ||= attr
+              @klass::PREDICATES[:"#{name}?"] ||= attr
+            end
+          end
+
+          def new(data = {}, errors = Errors.new)
+            @klass.new(data, errors, self)
           end
         end
 
@@ -46,56 +93,9 @@ module GraphQL
             field_classes[result_name.to_sym] = schema_module.define_class(definition, field_ast_nodes, field_return_type)
           end
 
-          klass = Class.new(self)
-          klass.define_fields(field_classes)
-          klass.instance_variable_set(:@source_definition, definition)
-          klass.instance_variable_set(:@_spreads, definition.indexes[:spreads][ast_nodes.first])
-
-          if definition.client.enforce_collocated_callers
-            keys = field_classes.keys.map { |key| ActiveSupport::Inflector.underscore(key) }
-            Client.enforce_collocated_callers(klass, keys, definition.source_location[0])
-          end
+          spreads = definition.indexes[:spreads][ast_nodes.first]
 
-          klass
-        end
-
-        PREDICATE_CACHE = Hash.new { |h, name|
-          h[name] = -> { @data[name] ? true : false }
-        }
-
-        METHOD_CACHE = Hash.new { |h, key|
-          h[key] = -> {
-            name = key.to_s
-            type = self.class::FIELDS[key]
-            @casted_data.fetch(name) do
-              @casted_data[name] = type.cast(@data[name], @errors.filter_by_path(name))
-            end
-          }
-        }
-
-        MODULE_CACHE = Hash.new do |h, fields|
-          h[fields] = Module.new do
-            fields.each do |name|
-              GraphQL::Client::Schema::ObjectType.define_cached_field(name, self)
-            end
-          end
-        end
-
-        FIELDS_CACHE = Hash.new { |h, k| h[k] = k }
-
-        def define_fields(fields)
-          const_set :FIELDS, FIELDS_CACHE[fields]
-          mod = MODULE_CACHE[fields.keys.sort]
-          include mod
-        end
-
-        def self.define_cached_field(name, ctx)
-          key = name
-          name = -name.to_s
-          method_name = ActiveSupport::Inflector.underscore(name)
-
-          ctx.send(:define_method, method_name, &METHOD_CACHE[key])
-          ctx.send(:define_method, "#{method_name}?", &PREDICATE_CACHE[name])
+          WithDefinition.new(self, field_classes, definition, spreads)
         end
 
         def define_field(name, type)
@@ -132,14 +132,13 @@ module GraphQL
           case selected_ast_node
           when GraphQL::Language::Nodes::InlineFragment
             continue_selection = if selected_ast_node.type.nil?
-              true
-            else
-              schema = definition.client.schema
-              type_condition = definition.client.get_type(selected_ast_node.type.name)
-              applicable_types = schema.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|
@@ -150,10 +149,8 @@ module GraphQL
             fragment_definition = definition.document.definitions.find do |defn|
               defn.is_a?(GraphQL::Language::Nodes::FragmentDefinition) && defn.name == selected_ast_node.name
             end
-
-            schema = definition.client.schema
             type_condition = definition.client.get_type(fragment_definition.type.name)
-            applicable_types = schema.possible_types(type_condition)
+            applicable_types = definition.client.possible_types(type_condition)
             # continue if this object type is one of the types matching the fragment condition
             continue_selection = applicable_types.include?(type)
 
@@ -177,17 +174,16 @@ module GraphQL
       end
 
       class ObjectClass
-        module ClassMethods
-          attr_reader :source_definition
-          attr_reader :_spreads
-        end
-
-        extend ClassMethods
-
-        def initialize(data = {}, errors = Errors.new)
+        def initialize(data = {}, errors = Errors.new, definer = nil)
           @data = data
           @casted_data = {}
           @errors = errors
+
+          # If we are not provided a definition, we can use this empty default
+          definer ||= ObjectType::WithDefinition.new(self.class, {}, nil, [])
+
+          @definer = definer
+          @enforce_collocated_callers = source_definition && source_definition.client.enforce_collocated_callers
         end
 
         # Public: Returns the raw response data
@@ -197,42 +193,85 @@ module GraphQL
           @data
         end
 
-        # Public: Return errors associated with data.
-        #
-        # Returns Errors collection.
-        attr_reader :errors
+        def _definer
+          @definer
+        end
 
-        def method_missing(*args)
-          super
-        rescue NoMethodError => e
-          type = self.class.type
+        def _spreads
+          @definer.spreads
+        end
 
-          if ActiveSupport::Inflector.underscore(e.name.to_s) != e.name.to_s
-            raise e
-          end
+        def source_definition
+          @definer.definition
+        end
 
-          all_fields = type.respond_to?(:all_fields) ? type.all_fields : type.fields.values
-          field = all_fields.find do |f|
-            f.name == e.name.to_s || ActiveSupport::Inflector.underscore(f.name) == e.name.to_s
+        def respond_to_missing?(name, priv)
+          if (attr = self.class::READERS[name]) || (attr = self.class::PREDICATES[name])
+            @definer.defined_fields.key?(attr) || super
+          else
+            super
           end
+        end
 
-          unless field
-            raise UnimplementedFieldError, "undefined field `#{e.name}' on #{type.graphql_name} type. https://git.io/v1y3m"
+        # Public: Return errors associated with data.
+        #
+        # It's possible to define "errors" as a field. Ideally this shouldn't
+        # happen, but if it does we should prefer the field rather than the
+        # builtin error type.
+        #
+        # Returns Errors collection.
+        def errors
+          if type = @definer.defined_fields["errors"]
+            read_attribute("errors", type)
+          else
+            @errors
           end
+        end
 
-          if @data.key?(field.name)
-            error_class = ImplicitlyFetchedFieldError
-            message = "implicitly fetched field `#{field.name}' on #{type} type. https://git.io/v1yGL"
+        def method_missing(name, *args)
+          if (attr = self.class::READERS[name]) && (type = @definer.defined_fields[attr])
+            if @enforce_collocated_callers
+              verify_collocated_path do
+                read_attribute(attr, type)
+              end
+            else
+              read_attribute(attr, type)
+            end
+          elsif (attr = self.class::PREDICATES[name]) && @definer.defined_fields[attr]
+            has_attribute?(attr)
           else
-            error_class = UnfetchedFieldError
-            message = "unfetched field `#{field.name}' on #{type} type. https://git.io/v1y3U"
-          end
+            begin
+              super
+            rescue NoMethodError => e
+              type = self.class.type
 
-          raise error_class, message
+              if ActiveSupport::Inflector.underscore(e.name.to_s) != e.name.to_s
+                raise e
+              end
+
+              all_fields = type.respond_to?(:all_fields) ? type.all_fields : type.fields.values
+              field = all_fields.find do |f|
+                f.name == e.name.to_s || ActiveSupport::Inflector.underscore(f.name) == e.name.to_s
+              end
+
+              unless field
+                raise UnimplementedFieldError, "undefined field `#{e.name}' on #{type.graphql_name} type. https://git.io/v1y3m"
+              end
+
+              if @data.key?(field.name)
+                raise ImplicitlyFetchedFieldError, "implicitly fetched field `#{field.name}' on #{type} type. https://git.io/v1yGL"
+              else
+                raise UnfetchedFieldError, "unfetched field `#{field.name}' on #{type} type. https://git.io/v1y3U"
+              end
+            end
+          end
         end
 
         def inspect
-          parent = self.class.ancestors.select { |m| m.is_a?(ObjectType) }.last
+          parent = self.class
+          until parent.superclass == ObjectClass
+            parent = parent.superclass
+          end
 
           ivars = @data.map { |key, value|
             if value.is_a?(Hash) || value.is_a?(Array)
@@ -247,6 +286,26 @@ module GraphQL
           buf << ">"
           buf
         end
+
+        private
+
+        def verify_collocated_path
+          location = caller_locations(2, 1)[0]
+
+          CollocatedEnforcement.verify_collocated_path(location, source_definition.source_location[0]) do
+            yield
+          end
+        end
+
+        def read_attribute(attr, type)
+          @casted_data.fetch(attr) do
+            @casted_data[attr] = type.cast(@data[attr], @errors.filter_by_path(attr))
+          end
+        end
+
+        def has_attribute?(attr)
+          !!@data[attr]
+        end
       end
     end
   end

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

@@ -21,7 +21,7 @@ module GraphQL
         end
 
         def define_class(definition, ast_nodes)
-          possible_type_names = definition.client.schema.possible_types(type).map(&:graphql_name)
+          possible_type_names = definition.client.possible_types(type).map(&:graphql_name)
           possible_types = possible_type_names.map { |concrete_type_name|
             schema_module.get_class(concrete_type_name).define_class(definition, ast_nodes)
           }

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/view_module.rb

@@ -133,7 +133,7 @@ module GraphQL
 
         remove_const(name) if placeholder
         const_set(name, mod)
-        mod.unloadable
+        mod.unloadable if mod.respond_to?(:unloadable)
         mod
       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"
@@ -49,12 +50,12 @@ module GraphQL
       when GraphQL::Schema, Class
         schema
       when Hash
-        GraphQL::Schema::Loader.load(schema)
+        GraphQL::Schema.from_introspection(schema)
       when String
         if schema.end_with?(".json") && File.exist?(schema)
           load_schema(File.read(schema))
         elsif schema =~ /\A\s*{/
-          load_schema(JSON.parse(schema))
+          load_schema(JSON.parse(schema, freeze: true))
         end
       else
         if schema.respond_to?(:execute)
@@ -97,10 +98,31 @@ module GraphQL
       @document_tracking_enabled = false
       @allow_dynamic_queries = false
       @enforce_collocated_callers = enforce_collocated_callers
-
+      if schema.is_a?(Class)
+        @possible_types = schema.possible_types
+      end
       @types = Schema.generate(@schema)
     end
 
+    # A cache of the schema's merged possible types
+    # @param type_condition [Class, String] a type definition or type name
+    def possible_types(type_condition = nil)
+      if type_condition
+        if defined?(@possible_types)
+          if type_condition.respond_to?(:graphql_name)
+            type_condition = type_condition.graphql_name
+          end
+          @possible_types[type_condition]
+        else
+          @schema.possible_types(type_condition)
+        end
+      elsif defined?(@possible_types)
+        @possible_types
+      else
+        @schema.possible_types(type_condition)
+      end
+    end
+
     def parse(str, filename = nil, lineno = nil)
       if filename.nil? && lineno.nil?
         location = caller_locations(1, 1).first
@@ -135,11 +157,7 @@ module GraphQL
           # which corresponds to the spread.
           # We depend on ActiveSupport to either find the already-loaded
           # constant, or to load the constant by name
-          begin
-            fragment = ActiveSupport::Inflector.constantize(const_name)
-          rescue NameError
-            fragment = nil
-          end
+          fragment = ActiveSupport::Inflector.safe_constantize(const_name)
 
           case fragment
           when FragmentDefinition
@@ -173,12 +191,8 @@ module GraphQL
 
       doc.definitions.each do |node|
         if node.name.nil?
-          if node.respond_to?(:merge) # GraphQL 1.9 +
-            node_with_name = node.merge(name: "__anonymous__")
-            doc = doc.replace_child(node, node_with_name)
-          else
-            node.name = "__anonymous__"
-          end
+          node_with_name = node.merge(name: "__anonymous__")
+          doc = doc.replace_child(node, node_with_name)
         end
       end
 
@@ -200,37 +214,13 @@ module GraphQL
         raise error
       end
 
-      definitions = {}
-      doc.definitions.each do |node|
-        sliced_document = Language::DefinitionSlice.slice(document_dependencies, node.name)
-        definition = Definition.for(
-          client: self,
-          ast_node: node,
-          document: sliced_document,
-          source_document: doc,
-          source_location: source_location
-        )
-        definitions[node.name] = definition
-      end
+      definitions = sliced_definitions(document_dependencies, doc, source_location: source_location)
 
-      if @document.respond_to?(:merge) # GraphQL 1.9+
-        visitor = RenameNodeVisitor.new(document_dependencies, definitions: definitions)
-        visitor.visit
-      else
-        name_hook = RenameNodeHook.new(definitions)
-        visitor = Language::Visitor.new(document_dependencies)
-        visitor[Language::Nodes::FragmentDefinition].leave << name_hook.method(:rename_node)
-        visitor[Language::Nodes::OperationDefinition].leave << name_hook.method(:rename_node)
-        visitor[Language::Nodes::FragmentSpread].leave << name_hook.method(:rename_node)
-        visitor.visit
-      end
+      visitor = RenameNodeVisitor.new(document_dependencies, definitions: definitions)
+      visitor.visit
 
       if document_tracking_enabled
-        if @document.respond_to?(:merge) # GraphQL 1.9+
-          @document = @document.merge(definitions: @document.definitions + doc.definitions)
-        else
-          @document.definitions.concat(doc.definitions)
-        end
+        @document = @document.merge(definitions: @document.definitions + doc.definitions)
       end
 
       if definitions["__anonymous__"]
@@ -276,27 +266,9 @@ module GraphQL
       end
     end
 
-    class RenameNodeHook
-      def initialize(definitions)
-        @definitions = definitions
-      end
-
-      def rename_node(node, _parent)
-        definition = @definitions[node.name]
-        if definition
-          node.extend(LazyName)
-          node._definition = definition
-        end
-      end
-    end
-
     # Public: A wrapper to use the more-efficient `.get_type` when it's available from GraphQL-Ruby (1.10+)
     def get_type(type_name)
-      if @schema.respond_to?(:get_type)
-        @schema.get_type(type_name)
-      else
-        @schema.types[type_name]
-      end
+      @schema.get_type(type_name)
     end
 
     # Public: Create operation definition from a fragment definition.
@@ -424,6 +396,58 @@ module GraphQL
 
     private
 
+    def sliced_definitions(document_dependencies, doc, source_location:)
+      dependencies = document_dependencies.definitions.map do |node|
+        [node.name, find_definition_dependencies(node)]
+      end.to_h
+
+      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
+          next if deps.include?(name)
+          deps.add(name)
+          queue.concat dependencies[name]
+        end
+
+        definitions = document_dependencies.definitions.select { |x| deps.include?(x.name)  }
+        sliced_document = Language::Nodes::Document.new(definitions: definitions)
+        definition = Definition.for(
+          client: self,
+          ast_node: node,
+          document: sliced_document,
+          source_document: doc,
+          source_location: source_location
+        )
+
+        [node.name, definition]
+      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)
+      visitor = GatherNamesVisitor.new(node)
+      visitor.visit
+      names = visitor.names
+      names.uniq!
+      names
+    end
+
     def deep_freeze_json_object(obj)
       case obj
       when String

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.16.0
+  version: 0.19.0
 platform: ruby
 authors:
 - GitHub
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-10-09 00:00:00.000000000 Z
+date: 2024-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -28,16 +28,16 @@ dependencies:
   name: graphql
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: actionpack
   requirement: !ruby/object:Gem::Requirement
@@ -100,42 +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'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.55'
+        version: 1.57.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.55'
+        version: 1.57.0
 description: A Ruby library for declaring, composing and executing GraphQL queries
 email: engineering@github.com
 executables: []
@@ -176,6 +176,7 @@ 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
@@ -183,7 +184,7 @@ homepage: https://github.com/github/graphql-client
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -198,8 +199,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: GraphQL Client
 test_files: []