graphql 1.12.25 → 1.13.0

data/lib/graphql/schema/type_membership.rb

@@ -4,8 +4,6 @@ module GraphQL
   class Schema
     # This class joins an object type to an abstract type (interface or union) of which
     # it is a member.
-    #
-    # TODO: Not yet implemented for interfaces.
     class TypeMembership
       # @return [Class<GraphQL::Schema::Object>]
       attr_accessor :object_type
@@ -26,9 +24,25 @@ module GraphQL
       end
 
       # @return [Boolean] if false, {#object_type} will be treated as _not_ a member of {#abstract_type}
-      def visible?(_ctx)
-        true
+      def visible?(ctx)
+        warden = Warden.from_context(ctx)
+        (@object_type.respond_to?(:visible?) ? warden.visible_type?(@object_type, ctx) : true) &&
+          (@abstract_type.respond_to?(:visible?) ? warden.visible_type?(@abstract_type, ctx) : true)
       end
+
+      def graphql_name
+        "#{@object_type.graphql_name}.#{@abstract_type.kind.interface? ? "implements" : "belongsTo" }.#{@abstract_type.graphql_name}"
+      end
+
+      def path
+        graphql_name
+      end
+
+      def inspect
+        "#<#{self.class} #{@object_type.inspect} => #{@abstract_type.inspect}>"
+      end
+
+      alias :type_class :itself
     end
   end
 end

data/lib/graphql/schema/union.rb

@@ -19,8 +19,9 @@ module GraphQL
             end
           else
             visible_types = []
+            warden = Warden.from_context(context)
             type_memberships.each do |type_membership|
-              if type_membership.visible?(context)
+              if warden.visible_type_membership?(type_membership, context)
                 visible_types << type_membership.object_type
               end
             end
@@ -28,6 +29,10 @@ module GraphQL
           end
         end
 
+        def all_possible_types
+          type_memberships.map(&:object_type)
+        end
+
         def to_graphql
           type_defn = GraphQL::UnionType.new
           type_defn.name = graphql_name

data/lib/graphql/schema/validator/format_validator.rb

@@ -18,10 +18,6 @@ module GraphQL
       #   # It's pretty hard to come up with a legitimate use case for `without:`
       #
       class FormatValidator < Validator
-        if !String.method_defined?(:match?)
-          using GraphQL::StringMatchBackport
-        end
-
         # @param with [RegExp, nil]
         # @param without [Regexp, nil]
         # @param message [String]

data/lib/graphql/schema/validator/numericality_validator.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   class Schema
     class Validator

data/lib/graphql/schema/warden.rb

@@ -37,6 +37,50 @@ module GraphQL
     #
     # @api private
     class Warden
+      def self.from_context(context)
+        (context.respond_to?(:warden) && context.warden) || PassThruWarden
+      end
+
+      # @param visibility_method [Symbol] a Warden method to call for this entry
+      # @param entry [Object, Array<Object>] One or more definitions for a given name in a GraphQL Schema
+      # @param context [GraphQL::Query::Context]
+      # @param warden [Warden]
+      # @return [Object] `entry` or one of `entry`'s items if exactly one of them is visible for this context
+      # @return [nil] If neither `entry` nor any of `entry`'s items are visible for this context
+      def self.visible_entry?(visibility_method, entry, context, warden = Warden.from_context(context))
+        if entry.is_a?(Array)
+          visible_item = nil
+          entry.each do |item|
+            if warden.public_send(visibility_method, item, context)
+              if visible_item.nil?
+                visible_item = item
+              else
+                raise Schema::DuplicateNamesError, "Found two visible definitions for `#{item.path}`: #{visible_item.inspect}, #{item.inspect}"
+              end
+            end
+          end
+          visible_item
+        elsif warden.public_send(visibility_method, entry, context)
+          entry
+        else
+          nil
+        end
+      end
+
+      # This is used when a caller provides a Hash for context.
+      # We want to call the schema's hooks, but we don't have a full-blown warden.
+      # The `context` arguments to these methods exist purely to simplify the code that
+      # calls methods on this object, so it will have everything it needs.
+      class PassThruWarden
+        class << self
+          def visible_field?(field, ctx); field.visible?(ctx); end
+          def visible_argument?(arg, ctx); arg.visible?(ctx); end
+          def visible_type?(type, ctx); type.visible?(ctx); end
+          def visible_enum_value?(ev, ctx); ev.visible?(ctx); end
+          def visible_type_membership?(tm, ctx); tm.visible?(ctx); end
+        end
+      end
+
       # @param filter [<#call(member)>] Objects are hidden when `.call(member, ctx)` returns true
       # @param context [GraphQL::Query::Context]
       # @param schema [GraphQL::Schema]
@@ -54,8 +98,8 @@ module GraphQL
       def types
         @types ||= begin
           vis_types = {}
-          @schema.types.each do |n, t|
-            if visible_type?(t)
+          @schema.types(@context).each do |n, t|
+            if visible_and_reachable_type?(t)
               vis_types[n] = t
             end
           end
@@ -66,8 +110,8 @@ module GraphQL
       # @return [GraphQL::BaseType, nil] The type named `type_name`, if it exists (else `nil`)
       def get_type(type_name)
         @visible_types ||= read_through do |name|
-          type_defn = @schema.get_type(name)
-          if type_defn && visible_type?(type_defn)
+          type_defn = @schema.get_type(name, @context)
+          if type_defn && visible_and_reachable_type?(type_defn)
             type_defn
           else
             nil
@@ -84,7 +128,7 @@ module GraphQL
 
       # @return Boolean True if the type is visible and reachable in the schema
       def reachable_type?(type_name)
-        type = get_type(type_name)
+        type = get_type(type_name) # rubocop:disable Development/ContextIsPassedCop -- `self` is query-aware
         type && reachable_type_set.include?(type)
       end
 
@@ -92,8 +136,8 @@ module GraphQL
       def get_field(parent_type, field_name)
         @visible_parent_fields ||= read_through do |type|
           read_through do |f_name|
-            field_defn = @schema.get_field(type, f_name)
-            if field_defn && visible_field?(type, field_defn)
+            field_defn = @schema.get_field(type, f_name, @context)
+            if field_defn && visible_field?(field_defn, nil, type)
               field_defn
             else
               nil
@@ -106,15 +150,15 @@ module GraphQL
 
       # @return [GraphQL::Argument, nil] The argument named `argument_name` on `parent_type`, if it exists and is visible
       def get_argument(parent_type, argument_name)
-        argument = parent_type.get_argument(argument_name)
-        return argument if argument && visible_argument?(argument)
+        argument = parent_type.get_argument(argument_name, @context)
+        return argument if argument && visible_argument?(argument, @context)
       end
 
       # @return [Array<GraphQL::BaseType>] The types which may be member of `type_defn`
       def possible_types(type_defn)
         @visible_possible_types ||= read_through { |type_defn|
           pt = @schema.possible_types(type_defn, @context)
-          pt.select { |t| visible_type?(t) }
+          pt.select { |t| visible_and_reachable_type?(t) }
         }
         @visible_possible_types[type_defn]
       end
@@ -122,26 +166,31 @@ module GraphQL
       # @param type_defn [GraphQL::ObjectType, GraphQL::InterfaceType]
       # @return [Array<GraphQL::Field>] Fields on `type_defn`
       def fields(type_defn)
-        @visible_fields ||= read_through { |t| @schema.get_fields(t).each_value.select { |f| visible_field?(t, f) } }
+        @visible_fields ||= read_through { |t| @schema.get_fields(t, @context).values }
         @visible_fields[type_defn]
       end
 
       # @param argument_owner [GraphQL::Field, GraphQL::InputObjectType]
       # @return [Array<GraphQL::Argument>] Visible arguments on `argument_owner`
       def arguments(argument_owner)
-        @visible_arguments ||= read_through { |o| o.arguments.each_value.select { |a| visible_argument?(a) } }
+        @visible_arguments ||= read_through { |o| o.arguments(@context).each_value.select { |a| visible_argument?(a) } }
         @visible_arguments[argument_owner]
       end
 
       # @return [Array<GraphQL::EnumType::EnumValue>] Visible members of `enum_defn`
       def enum_values(enum_defn)
-        @visible_enum_values ||= read_through { |e| e.values.each_value.select { |enum_value_defn| visible?(enum_value_defn) } }
-        @visible_enum_values[enum_defn]
+        @visible_enum_arrays ||= read_through { |e| e.enum_values(@context) }
+        @visible_enum_arrays[enum_defn]
+      end
+
+      def visible_enum_value?(enum_value, _ctx = nil)
+        @visible_enum_values ||= read_through { |ev| visible?(ev) }
+        @visible_enum_values[enum_value]
       end
 
       # @return [Array<GraphQL::InterfaceType>] Visible interfaces implemented by `obj_type`
       def interfaces(obj_type)
-        @visible_interfaces ||= read_through { |t| t.interfaces(@context).select { |i| visible?(i) } }
+        @visible_interfaces ||= read_through { |t| t.interfaces(@context).select { |i| visible_type?(i) } }
         @visible_interfaces[obj_type]
       end
 
@@ -158,25 +207,52 @@ module GraphQL
         end
       end
 
-      private
-
-      def union_memberships(obj_type)
-        @unions ||= read_through { |obj_type| @schema.union_memberships(obj_type).select { |u| visible?(u) } }
-        @unions[obj_type]
-      end
-
-      def visible_argument?(arg_defn)
-        visible?(arg_defn) && visible_type?(arg_defn.type.unwrap)
-      end
-
-      def visible_field?(owner_type, field_defn)
+      # @param owner [Class, Module] If provided, confirm that field has the given owner.
+      def visible_field?(field_defn, _ctx = nil, owner = field_defn.owner)
         # This field is visible in its own right
         visible?(field_defn) &&
           # This field's return type is visible
-          visible_type?(field_defn.type.unwrap) &&
+          visible_and_reachable_type?(field_defn.type.unwrap) &&
           # This field is either defined on this object type,
           # or the interface it's inherited from is also visible
-          ((field_defn.respond_to?(:owner) && field_defn.owner == owner_type) || field_on_visible_interface?(field_defn, owner_type))
+          ((field_defn.respond_to?(:owner) && field_defn.owner == owner) || field_on_visible_interface?(field_defn, owner))
+      end
+
+      def visible_argument?(arg_defn, _ctx = nil)
+        visible?(arg_defn) && visible_and_reachable_type?(arg_defn.type.unwrap)
+      end
+
+      def visible_type?(type_defn, _ctx = nil)
+        @type_visibility ||= read_through { |type_defn| visible?(type_defn) }
+        @type_visibility[type_defn]
+      end
+
+      def visible_type_membership?(type_membership, _ctx = nil)
+        visible?(type_membership)
+      end
+
+      private
+
+      def visible_and_reachable_type?(type_defn)
+        @visible_and_reachable_type ||= read_through do |type_defn|
+          next false unless visible_type?(type_defn)
+          next true if root_type?(type_defn) || type_defn.introspection?
+
+          if type_defn.kind.union?
+            visible_possible_types?(type_defn) && (referenced?(type_defn) || orphan_type?(type_defn))
+          elsif type_defn.kind.interface?
+            visible_possible_types?(type_defn)
+          else
+            referenced?(type_defn) || visible_abstract_type?(type_defn)
+          end
+        end
+
+        @visible_and_reachable_type[type_defn]
+      end
+
+      def union_memberships(obj_type)
+        @unions ||= read_through { |obj_type| @schema.union_memberships(obj_type).select { |u| visible?(u) } }
+        @unions[obj_type]
       end
 
       # We need this to tell whether a field was inherited by an interface
@@ -195,10 +271,10 @@ module GraphQL
           any_interface_has_visible_field = false
           ints = unfiltered_interfaces(type_defn)
           ints.each do |interface_type|
-            if (iface_field_defn = interface_type.get_field(field_defn.graphql_name))
+            if (iface_field_defn = interface_type.get_field(field_defn.graphql_name, @context))
               any_interface_has_field = true
 
-              if interfaces(type_defn).include?(interface_type) && visible_field?(interface_type, iface_field_defn)
+              if interfaces(type_defn).include?(interface_type) && visible_field?(iface_field_defn, nil, interface_type)
                 any_interface_has_visible_field = true
               end
             end
@@ -215,23 +291,6 @@ module GraphQL
         end
       end
 
-      def visible_type?(type_defn)
-        @type_visibility ||= read_through do |type_defn|
-          next false unless visible?(type_defn)
-          next true if root_type?(type_defn) || type_defn.introspection?
-
-          if type_defn.kind.union?
-            visible_possible_types?(type_defn) && (referenced?(type_defn) || orphan_type?(type_defn))
-          elsif type_defn.kind.interface?
-            visible_possible_types?(type_defn)
-          else
-            referenced?(type_defn) || visible_abstract_type?(type_defn)
-          end
-        end
-
-        @type_visibility[type_defn]
-      end
-
       def root_type?(type_defn)
         @query == type_defn ||
           @mutation == type_defn ||
@@ -259,7 +318,7 @@ module GraphQL
       end
 
       def visible_possible_types?(type_defn)
-        possible_types(type_defn).any? { |t| visible_type?(t) }
+        possible_types(type_defn).any? { |t| visible_and_reachable_type?(t) }
       end
 
       def visible?(member)
@@ -274,6 +333,7 @@ module GraphQL
         return @reachable_type_set if defined?(@reachable_type_set)
 
         @reachable_type_set = Set.new
+        rt_hash = {}
 
         unvisited_types = []
         ['query', 'mutation', 'subscription'].each do |op_name|
@@ -283,16 +343,16 @@ module GraphQL
         unvisited_types.concat(@schema.introspection_system.types.values)
 
         directives.each do |dir_class|
-          dir_class.arguments.values.each do |arg_defn|
+          arguments(dir_class).each do |arg_defn|
             arg_t = arg_defn.type.unwrap
-            if get_type(arg_t.graphql_name)
+            if get_type(arg_t.graphql_name) # rubocop:disable Development/ContextIsPassedCop -- `self` is query-aware
               unvisited_types << arg_t
             end
           end
         end
 
         @schema.orphan_types.each do |orphan_type|
-          if get_type(orphan_type.graphql_name)
+          if get_type(orphan_type.graphql_name) == orphan_type # rubocop:disable Development/ContextIsPassedCop -- `self` is query-aware
             unvisited_types << orphan_type
           end
         end
@@ -300,6 +360,10 @@ module GraphQL
         until unvisited_types.empty?
           type = unvisited_types.pop
           if @reachable_type_set.add?(type)
+            type_by_name = rt_hash[type.graphql_name] ||= type
+            if type_by_name != type
+              raise DuplicateNamesError, "Found two visible type definitions for `#{type.graphql_name}`: #{type.inspect}, #{type_by_name.inspect}"
+            end
             if type.kind.input_object?
               # recurse into visible arguments
               arguments(type).each do |argument|

data/lib/graphql/schema.rb

@@ -92,6 +92,8 @@ module GraphQL
       end
     end
 
+    class DuplicateNamesError < GraphQL::Error; end
+
     class UnresolvedLateBoundTypeError < GraphQL::Error
       attr_reader :type
       def initialize(type:)
@@ -996,16 +998,58 @@ module GraphQL
       # Build a map of `{ name => type }` and return it
       # @return [Hash<String => Class>] A dictionary of type classes by their GraphQL name
       # @see get_type Which is more efficient for finding _one type_ by name, because it doesn't merge hashes.
-      def types
-        non_introspection_types.merge(introspection_system.types)
+      def types(context = GraphQL::Query::NullContext)
+        all_types = non_introspection_types.merge(introspection_system.types)
+        visible_types = {}
+        all_types.each do |k, v|
+          visible_types[k] =if v.is_a?(Array)
+            visible_t = nil
+            v.each do |t|
+              if t.visible?(context)
+                if visible_t.nil?
+                  visible_t = t
+                else
+                  raise DuplicateNamesError, "Found two visible type definitions for `#{k}`: #{visible_t.inspect}, #{t.inspect}"
+                end
+              end
+            end
+            visible_t
+          else
+            v
+          end
+        end
+        visible_types
       end
 
       # @param type_name [String]
       # @return [Module, nil] A type, or nil if there's no type called `type_name`
-      def get_type(type_name)
-        own_types[type_name] ||
-          introspection_system.types[type_name] ||
-          find_inherited_value(:types, EMPTY_HASH)[type_name]
+      def get_type(type_name, context = GraphQL::Query::NullContext)
+        local_entry = own_types[type_name]
+        type_defn = case local_entry
+        when nil
+          nil
+        when Array
+          visible_t = nil
+          warden = Warden.from_context(context)
+          local_entry.each do |t|
+            if warden.visible_type?(t, context)
+              if visible_t.nil?
+                visible_t = t
+              else
+                raise DuplicateNamesError, "Found two visible type definitions for `#{type_name}`: #{visible_t.inspect}, #{t.inspect}"
+              end
+            end
+          end
+          visible_t
+        when Module
+          local_entry
+        else
+          raise "Invariant: unexpected own_types[#{type_name.inspect}]: #{local_entry.inspect}"
+        end
+
+        type_defn ||
+          introspection_system.types[type_name] || # todo context-specific introspection?
+          (superclass.respond_to?(:get_type) ? superclass.get_type(type_name, context) : nil)
       end
 
       # @api private
@@ -1182,19 +1226,19 @@ module GraphQL
         GraphQL::Schema::TypeExpression.build_type(type_owner, ast_node)
       end
 
-      def get_field(type_or_name, field_name)
+      def get_field(type_or_name, field_name, context = GraphQL::Query::NullContext)
         parent_type = case type_or_name
         when LateBoundType
-          get_type(type_or_name.name)
+          get_type(type_or_name.name, context)
         when String
-          get_type(type_or_name)
+          get_type(type_or_name, context)
         when Module
           type_or_name
         else
           raise ArgumentError, "unexpected field owner for #{field_name.inspect}: #{type_or_name.inspect} (#{type_or_name.class})"
         end
 
-        if parent_type.kind.fields? && (field = parent_type.get_field(field_name))
+        if parent_type.kind.fields? && (field = parent_type.get_field(field_name, context))
           field
         elsif parent_type == query && (entry_point_field = introspection_system.entry_point(name: field_name))
           entry_point_field
@@ -1205,8 +1249,8 @@ module GraphQL
         end
       end
 
-      def get_fields(type)
-        type.fields
+      def get_fields(type, context = GraphQL::Query::NullContext)
+        type.fields(context)
       end
 
       def introspection(new_introspection_namespace = nil)
@@ -1405,7 +1449,6 @@ module GraphQL
         if new_orphan_types.any?
           new_orphan_types = new_orphan_types.flatten
           add_type_and_traverse(new_orphan_types, root: false)
-          @orphan_types = new_orphan_types
           own_orphan_types.concat(new_orphan_types.flatten)
         end
 
@@ -1715,7 +1758,7 @@ module GraphQL
           if subscription.singleton_class.ancestors.include?(Subscriptions::SubscriptionRoot)
             GraphQL::Deprecation.warn("`extend Subscriptions::SubscriptionRoot` is no longer required; you may remove it from #{self}'s `subscription` root type (#{subscription}).")
           else
-            subscription.fields.each do |name, field|
+            subscription.all_field_definitions.each do |field|
               field.extension(Subscriptions::DefaultSubscriptionResolveExtension)
             end
           end
@@ -1737,7 +1780,36 @@ module GraphQL
         end
         new_types = Array(t)
         addition = Schema::Addition.new(schema: self, own_types: own_types, new_types: new_types)
-        own_types.merge!(addition.types)
+        addition.types.each do |name, types_entry| # rubocop:disable Development/ContextIsPassedCop -- build-time, not query-time
+          if (prev_entry = own_types[name])
+            prev_entries = case prev_entry
+            when Array
+              prev_entry
+            when Module
+              own_types[name] = [prev_entry]
+            else
+              raise "Invariant: unexpected prev_entry at #{name.inspect} when adding #{t.inspect}"
+            end
+
+            case types_entry
+            when Array
+              prev_entries.concat(types_entry)
+              prev_entries.uniq! # in case any are being re-visited
+            when Module
+              if !prev_entries.include?(types_entry)
+                prev_entries << types_entry
+              end
+            else
+              raise "Invariant: unexpected types_entry at #{name} when adding #{t.inspect}"
+            end
+          else
+            if types_entry.is_a?(Array)
+              types_entry.uniq!
+            end
+            own_types[name] = types_entry
+          end
+        end
+
         own_possible_types.merge!(addition.possible_types) { |key, old_val, new_val| old_val + new_val }
         own_union_memberships.merge!(addition.union_memberships)
 

data/lib/graphql/static_validation/base_visitor.rb

@@ -94,7 +94,7 @@ module GraphQL
 
         def on_field(node, parent)
           parent_type = @object_types.last
-          field_definition = @schema.get_field(parent_type, node.name)
+          field_definition = @schema.get_field(parent_type, node.name, @context.query.context)
           @field_definitions.push(field_definition)
           if !field_definition.nil?
             next_object_type = field_definition.type.unwrap
@@ -120,14 +120,14 @@ module GraphQL
           argument_defn = if (arg = @argument_definitions.last)
             arg_type = arg.type.unwrap
             if arg_type.kind.input_object?
-              arg_type.arguments[node.name]
+              @context.warden.get_argument(arg_type, node.name)
             else
               nil
             end
           elsif (directive_defn = @directive_definitions.last)
-            directive_defn.arguments[node.name]
+            @context.warden.get_argument(directive_defn, node.name)
           elsif (field_defn = @field_definitions.last)
-            field_defn.arguments[node.name]
+            @context.warden.get_argument(field_defn, node.name)
           else
             nil
           end
@@ -187,7 +187,7 @@ module GraphQL
 
         def on_fragment_with_type(node)
           object_type = if node.type
-            @schema.get_type(node.type.name)
+            @context.warden.get_type(node.type.name)
           else
             @object_types.last
           end

data/lib/graphql/static_validation/definition_dependencies.rb

@@ -70,7 +70,6 @@ module GraphQL
         @dependency_map ||= resolve_dependencies(&block)
       end
 
-
       # Map definition AST nodes to the definition AST nodes they depend on.
       # Expose circular dependencies.
       class DependencyMap

data/lib/graphql/static_validation/literal_validator.rb

@@ -95,7 +95,7 @@ module GraphQL
       def required_input_fields_are_present(type, ast_node)
         # TODO - would be nice to use these to create an error message so the caller knows
         # that required fields are missing
-        required_field_names = type.arguments.each_value
+        required_field_names = @warden.arguments(type)
           .select { |argument| argument.type.kind.non_null? && @warden.get_argument(type, argument.name) }
           .map(&:name)
 

data/lib/graphql/static_validation/rules/argument_literals_are_compatible.rb

@@ -15,7 +15,7 @@ module GraphQL
         if @context.schema.error_bubbling || context.errors.none? { |err| err.path.take(@path.size) == @path }
           parent_defn = parent_definition(parent)
 
-          if parent_defn && (arg_defn = parent_defn.arguments[node.name])
+          if parent_defn && (arg_defn = context.warden.get_argument(parent_defn, node.name))
             validation_result = context.validate_literal(node.value, arg_defn.type)
             if !validation_result.valid?
               kind_of_node = node_type(parent)

data/lib/graphql/static_validation/rules/fields_will_merge.rb

@@ -50,15 +50,15 @@ module GraphQL
         @arg_conflicts = nil
 
         yield
-        # don't initialize these if they weren't initialized in the block:
-        @field_conflicts && @field_conflicts.each_value { |error| add_error(error) }
-        @arg_conflicts && @arg_conflicts.each_value { |error| add_error(error) }
+
+        field_conflicts.each_value { |error| add_error(error) }
+        arg_conflicts.each_value { |error| add_error(error) }
       end
 
       def conflicts_within_selection_set(node, parent_type)
         return if parent_type.nil?
 
-        fields, fragment_spreads = fields_and_fragments_from_selection(node, owner_type: parent_type, parents: nil)
+        fields, fragment_spreads = fields_and_fragments_from_selection(node, owner_type: parent_type, parents: [])
 
         # (A) Find find all conflicts "within" the fields of this selection set.
         find_conflicts_within(fields)
@@ -198,14 +198,10 @@ module GraphQL
         response_keys.each do |key, fields|
           next if fields.size < 2
           # find conflicts within nodes
-          i = 0
-          while i < fields.size
-            j = i + 1
-            while j < fields.size
+          for i in 0..fields.size - 1
+            for j in i + 1..fields.size - 1
               find_conflict(key, fields[i], fields[j])
-              j += 1
             end
-            i += 1
           end
         end
       end
@@ -247,9 +243,7 @@ module GraphQL
       end
 
       def find_conflicts_between_sub_selection_sets(field1, field2, mutually_exclusive:)
-        return if field1.definition.nil? ||
-          field2.definition.nil? ||
-          (field1.node.selections.empty? && field2.node.selections.empty?)
+        return if field1.definition.nil? || field2.definition.nil?
 
         return_type1 = field1.definition.type.unwrap
         return_type2 = field2.definition.type.unwrap
@@ -329,7 +323,6 @@ module GraphQL
         if node.selections.empty?
           NO_SELECTIONS
         else
-          parents ||= []
           fields, fragment_spreads = find_fields_and_fragments(node.selections, owner_type: owner_type, parents: parents, fields: [], fragment_spreads: [])
           response_keys = fields.group_by { |f| f.node.alias || f.node.name }
           [response_keys, fragment_spreads]
@@ -340,7 +333,7 @@ module GraphQL
         selections.each do |node|
           case node
           when GraphQL::Language::Nodes::Field
-            definition = context.schema.get_field(owner_type, node.name)
+            definition = context.query.get_field(owner_type, node.name)
             fields << Field.new(node, definition, owner_type, parents)
           when GraphQL::Language::Nodes::InlineFragment
             fragment_type = node.type ? context.warden.get_type(node.type.name) : owner_type

data/lib/graphql/static_validation/rules/required_arguments_are_present.rb

@@ -16,10 +16,8 @@ module GraphQL
       private
 
       def assert_required_args(ast_node, defn)
-        args = defn.arguments
-        return if args.empty?
         present_argument_names = ast_node.arguments.map(&:name)
-        required_argument_names = defn.arguments.each_value
+        required_argument_names = context.warden.arguments(defn)
           .select { |a| a.type.kind.non_null? && !a.default_value? && context.warden.get_argument(defn, a.name) }
           .map(&:name)