graphql 1.12.12 → 2.4.8

data/lib/graphql/static_validation/all_rules.rb

@@ -3,7 +3,7 @@ module GraphQL
   module StaticValidation
     # Default rules for {GraphQL::StaticValidation::Validator}
     #
-    # Order is important here. Some validators return {GraphQL::Language::Visitor::SKIP}
+    # Order is important here. Some validators skip later hooks.
     # which stops the visit on that node. That way it doesn't try to find fields on types that
     # don't exist, etc.
     ALL_RULES = [
@@ -33,8 +33,10 @@ module GraphQL
       GraphQL::StaticValidation::VariablesAreUsedAndDefined,
       GraphQL::StaticValidation::VariableUsagesAreAllowed,
       GraphQL::StaticValidation::MutationRootExists,
+      GraphQL::StaticValidation::QueryRootExists,
       GraphQL::StaticValidation::SubscriptionRootExists,
       GraphQL::StaticValidation::InputObjectNamesAreUnique,
+      GraphQL::StaticValidation::OneOfInputObjectsAreValid,
     ]
   end
 end

data/lib/graphql/static_validation/base_visitor.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class BaseVisitor < GraphQL::Language::Visitor
+    class BaseVisitor < GraphQL::Language::StaticVisitor
       def initialize(document, context)
         @path = []
         @object_types = []
@@ -10,15 +10,11 @@ module GraphQL
         @argument_definitions = []
         @directive_definitions = []
         @context = context
+        @types = context.query.types
         @schema = context.schema
         super(document)
       end
 
-      # This will be overwritten by {InternalRepresentation::Rewrite} if it's included
-      def rewrite_document
-        nil
-      end
-
       attr_reader :context
 
       # @return [Array<GraphQL::ObjectType>] Types whose scope we've entered
@@ -32,22 +28,13 @@ module GraphQL
       # Build a class to visit the AST and perform validation,
       # or use a pre-built class if rules is `ALL_RULES` or empty.
       # @param rules [Array<Module, Class>]
-      # @param rewrite [Boolean] if `false`, don't include rewrite
       # @return [Class] A class for validating `rules` during visitation
-      def self.including_rules(rules, rewrite: true)
+      def self.including_rules(rules)
         if rules.empty?
-          if rewrite
-            NoValidateVisitor
-          else
-            # It's not doing _anything?!?_
-            BaseVisitor
-          end
+          # It's not doing _anything?!?_
+          BaseVisitor
         elsif rules == ALL_RULES
-          if rewrite
-            DefaultVisitor
-          else
-            InterpreterVisitor
-          end
+          InterpreterVisitor
         else
           visitor_class = Class.new(self) do
             include(GraphQL::StaticValidation::DefinitionDependencies)
@@ -60,9 +47,6 @@ module GraphQL
             end
           end
 
-          if rewrite
-            visitor_class.include(GraphQL::InternalRepresentation::Rewrite)
-          end
           visitor_class.include(ContextMethods)
           visitor_class
         end
@@ -94,7 +78,7 @@ module GraphQL
 
         def on_field(node, parent)
           parent_type = @object_types.last
-          field_definition = @schema.get_field(parent_type, node.name)
+          field_definition = @types.field(parent_type, node.name)
           @field_definitions.push(field_definition)
           if !field_definition.nil?
             next_object_type = field_definition.type.unwrap
@@ -110,7 +94,7 @@ module GraphQL
         end
 
         def on_directive(node, parent)
-          directive_defn = @schema.directives[node.name]
+          directive_defn = @context.schema_directives[node.name]
           @directive_definitions.push(directive_defn)
           super
           @directive_definitions.pop
@@ -120,14 +104,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]
+              @types.argument(arg_type, node.name)
             else
               nil
             end
           elsif (directive_defn = @directive_definitions.last)
-            directive_defn.arguments[node.name]
+            @types.argument(directive_defn, node.name)
           elsif (field_defn = @field_definitions.last)
-            field_defn.arguments[node.name]
+            @types.argument(field_defn, node.name)
           else
             nil
           end
@@ -187,7 +171,7 @@ module GraphQL
 
         def on_fragment_with_type(node)
           object_type = if node.type
-            @schema.get_type(node.type.name)
+            @types.type(node.type.name)
           else
             @object_types.last
           end
@@ -205,6 +189,9 @@ module GraphQL
       private
 
       def add_error(error, path: nil)
+        if @context.too_many_errors?
+          throw :too_many_validation_errors
+        end
         error.path ||= (path || @path.dup)
         context.errors << error
       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
@@ -128,8 +127,14 @@ module GraphQL
         # same name as if they were the same name. If _any_ of the fragments
         # with that name has a dependency, we record it.
         independent_fragment_nodes = @defdep_fragment_definitions.values.flatten - @defdep_immediate_dependencies.keys
-
+        visited_fragment_names = Set.new
         while fragment_node = independent_fragment_nodes.pop
+          if visited_fragment_names.add?(fragment_node.name)
+            # this is a new fragment name
+          else
+            # this is a duplicate fragment name
+            next
+          end
           loops += 1
           if loops > max_loops
             raise("Resolution loops exceeded the number of definitions; infinite loop detected. (Max: #{max_loops}, Current: #{loops})")

data/lib/graphql/static_validation/error.rb

@@ -30,10 +30,12 @@ module GraphQL
         }.tap { |h| h["path"] = path unless path.nil? }
       end
 
+      attr_reader :nodes
+
       private
 
       def locations
-        @nodes.map do |node|
+        nodes.map do |node|
           h = {"line" => node.line, "column" => node.col}
           h["filename"] = node.filename if node.filename
           h

data/lib/graphql/static_validation/literal_validator.rb

@@ -5,7 +5,7 @@ module GraphQL
     class LiteralValidator
       def initialize(context:)
         @context = context
-        @warden = context.warden
+        @types = context.types
         @invalid_response = GraphQL::Query::InputValidationResult.new(valid: false, problems: [])
         @valid_response = GraphQL::Query::InputValidationResult.new(valid: true, problems: [])
       end
@@ -18,6 +18,19 @@ module GraphQL
 
       private
 
+      def replace_nulls_in(ast_value)
+        case ast_value
+        when Array
+          ast_value.map { |v| replace_nulls_in(v) }
+        when GraphQL::Language::Nodes::InputObject
+          ast_value.to_h
+        when GraphQL::Language::Nodes::NullValue
+          nil
+        else
+          ast_value
+        end
+      end
+
       def recursively_validate(ast_value, type)
         if type.nil?
           # this means we're an undefined argument, see #present_input_field_values_are_valid
@@ -42,7 +55,8 @@ module GraphQL
           @valid_response
         elsif type.kind.scalar? && constant_scalar?(ast_value)
           maybe_raise_if_invalid(ast_value) do
-            type.validate_input(ast_value, @context)
+            ruby_value = replace_nulls_in(ast_value)
+            type.validate_input(ruby_value, @context)
           end
         elsif type.kind.enum?
           maybe_raise_if_invalid(ast_value) do
@@ -95,9 +109,9 @@ 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
-          .select { |argument| argument.type.kind.non_null? && @warden.get_argument(type, argument.name) }
-          .map(&:name)
+        required_field_names = @types.arguments(type)
+          .select { |argument| argument.type.kind.non_null? && !argument.default_value? }
+          .map!(&:name)
 
         present_field_names = ast_node.arguments.map(&:name)
         missing_required_field_names = required_field_names - present_field_names
@@ -105,16 +119,19 @@ module GraphQL
           missing_required_field_names.empty? ? @valid_response : @invalid_response
         else
           results = missing_required_field_names.map do |name|
-            arg_type = @warden.get_argument(type, name).type
+            arg_type = @types.argument(type, name).type
             recursively_validate(GraphQL::Language::Nodes::NullValue.new(name: name), arg_type)
           end
+          if type.one_of? && ast_node.arguments.size != 1
+            results << Query::InputValidationResult.from_problem("`#{type.graphql_name}` is a OneOf type, so only one argument may be given (instead of #{ast_node.arguments.size})")
+          end
           merge_results(results)
         end
       end
 
       def present_input_field_values_are_valid(type, ast_node)
         results = ast_node.arguments.map do |value|
-          field = @warden.get_argument(type, value.name)
+          field = @types.argument(type, value.name)
           # we want to call validate on an argument even if it's an invalid one
           # so that our raise exception is on it instead of the entire InputObject
           field_type = field && field.type

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 = @types.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/argument_names_are_unique.rb

@@ -16,7 +16,7 @@ module GraphQL
 
       def validate_arguments(node)
         argument_defns = node.arguments
-        if argument_defns.any?
+        if !argument_defns.empty?
           args_by_name = Hash.new { |h, k| h[k] = [] }
           argument_defns.each { |a| args_by_name[a.name] << a }
           args_by_name.each do |name, defns|

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

@@ -5,13 +5,14 @@ module GraphQL
       def on_argument(node, parent)
         parent_defn = parent_definition(parent)
 
-        if parent_defn && context.warden.get_argument(parent_defn, node.name)
+        if parent_defn && @types.argument(parent_defn, node.name)
           super
         elsif parent_defn
           kind_of_node = node_type(parent)
           error_arg_name = parent_name(parent, parent_defn)
+          arg_names = context.types.arguments(parent_defn).map(&:graphql_name)
           add_error(GraphQL::StaticValidation::ArgumentsAreDefinedError.new(
-            "#{kind_of_node} '#{error_arg_name}' doesn't accept argument '#{node.name}'",
+            "#{kind_of_node} '#{error_arg_name}' doesn't accept argument '#{node.name}'#{context.did_you_mean_suggestion(node.name, arg_names)}",
             nodes: node,
             name: error_arg_name,
             type: kind_of_node,
@@ -59,7 +60,7 @@ module GraphQL
             end
           end
         when GraphQL::Language::Nodes::Directive
-          context.schema.directives[parent.name]
+          context.schema_directives[parent.name]
         when GraphQL::Language::Nodes::Field
           context.field_definition
         else

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

@@ -4,16 +4,22 @@ module GraphQL
     module DirectivesAreDefined
       def initialize(*)
         super
-        @directive_names = context.warden.directives.map(&:graphql_name)
       end
 
       def on_directive(node, parent)
-        if !@directive_names.include?(node.name)
-          add_error(GraphQL::StaticValidation::DirectivesAreDefinedError.new(
-            "Directive @#{node.name} is not defined",
-            nodes: node,
-            directive: node.name
-          ))
+        if !@types.directive_exists?(node.name)
+          @directives_are_defined_errors_by_name ||= {}
+          error = @directives_are_defined_errors_by_name[node.name] ||= begin
+            @directive_names ||= @types.directives.map(&:graphql_name)
+            err = GraphQL::StaticValidation::DirectivesAreDefinedError.new(
+              "Directive @#{node.name} is not defined#{context.did_you_mean_suggestion(node.name, @directive_names)}",
+              nodes: [],
+              directive: node.name
+            )
+            add_error(err)
+            err
+          end
+          error.nodes << node
         else
           super
         end

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

@@ -5,27 +5,29 @@ module GraphQL
       include GraphQL::Language
 
       def on_directive(node, parent)
-        validate_location(node, parent, context.schema.directives)
+        validate_location(node, parent, context.schema_directives)
         super
       end
 
       private
 
       LOCATION_MESSAGE_NAMES = {
-        GraphQL::Directive::QUERY =>               "queries",
-        GraphQL::Directive::MUTATION =>            "mutations",
-        GraphQL::Directive::SUBSCRIPTION =>        "subscriptions",
-        GraphQL::Directive::FIELD =>               "fields",
-        GraphQL::Directive::FRAGMENT_DEFINITION => "fragment definitions",
-        GraphQL::Directive::FRAGMENT_SPREAD =>     "fragment spreads",
-        GraphQL::Directive::INLINE_FRAGMENT =>     "inline fragments",
+        GraphQL::Schema::Directive::QUERY =>               "queries",
+        GraphQL::Schema::Directive::MUTATION =>            "mutations",
+        GraphQL::Schema::Directive::SUBSCRIPTION =>        "subscriptions",
+        GraphQL::Schema::Directive::FIELD =>               "fields",
+        GraphQL::Schema::Directive::FRAGMENT_DEFINITION => "fragment definitions",
+        GraphQL::Schema::Directive::FRAGMENT_SPREAD =>     "fragment spreads",
+        GraphQL::Schema::Directive::INLINE_FRAGMENT =>     "inline fragments",
+        GraphQL::Schema::Directive::VARIABLE_DEFINITION => "variable definitions",
       }
 
       SIMPLE_LOCATIONS = {
-        Nodes::Field =>               GraphQL::Directive::FIELD,
-        Nodes::InlineFragment =>      GraphQL::Directive::INLINE_FRAGMENT,
-        Nodes::FragmentSpread =>      GraphQL::Directive::FRAGMENT_SPREAD,
-        Nodes::FragmentDefinition =>  GraphQL::Directive::FRAGMENT_DEFINITION,
+        Nodes::Field =>               GraphQL::Schema::Directive::FIELD,
+        Nodes::InlineFragment =>      GraphQL::Schema::Directive::INLINE_FRAGMENT,
+        Nodes::FragmentSpread =>      GraphQL::Schema::Directive::FRAGMENT_SPREAD,
+        Nodes::FragmentDefinition =>  GraphQL::Schema::Directive::FRAGMENT_DEFINITION,
+        Nodes::VariableDefinition =>  GraphQL::Schema::Directive::VARIABLE_DEFINITION,
       }
 
       SIMPLE_LOCATION_NODES = SIMPLE_LOCATIONS.keys
@@ -34,7 +36,7 @@ module GraphQL
         directive_defn = directives[ast_directive.name]
         case ast_parent
         when Nodes::OperationDefinition
-          required_location = GraphQL::Directive.const_get(ast_parent.operation_type.upcase)
+          required_location = GraphQL::Schema::Directive.const_get(ast_parent.operation_type.upcase)
           assert_includes_location(directive_defn, ast_directive, required_location)
         when *SIMPLE_LOCATION_NODES
           required_location = SIMPLE_LOCATIONS[ast_parent.class]

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

@@ -4,7 +4,7 @@ module GraphQL
     module FieldsAreDefinedOnType
       def on_field(node, parent)
         parent_type = @object_types[-2]
-        field = context.warden.get_field(parent_type, node.name)
+        field = context.query.types.field(parent_type, node.name)
 
         if field.nil?
           if parent_type.kind.union?
@@ -14,8 +14,11 @@ module GraphQL
               node_name: parent_type.graphql_name
             ))
           else
+            possible_fields = possible_fields(context, parent_type)
+            suggestion = context.did_you_mean_suggestion(node.name, possible_fields)
+            message = "Field '#{node.name}' doesn't exist on type '#{parent_type.graphql_name}'#{suggestion}"
             add_error(GraphQL::StaticValidation::FieldsAreDefinedOnTypeError.new(
-              "Field '#{node.name}' doesn't exist on type '#{parent_type.graphql_name}'",
+              message,
               nodes: node,
               field: node.name,
               type: parent_type.graphql_name
@@ -25,6 +28,13 @@ module GraphQL
           super
         end
       end
+
+      private
+
+      def possible_fields(context, parent_type)
+        return EmptyObjects::EMPTY_ARRAY if parent_type.kind.leaf?
+        context.types.fields(parent_type).map(&:graphql_name)
+      end
     end
   end
 end

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

@@ -25,12 +25,20 @@ module GraphQL
       def validate_field_selections(ast_node, resolved_type)
         msg = if resolved_type.nil?
           nil
-        elsif resolved_type.kind.scalar? && ast_node.selections.any?
-          if ast_node.selections.first.is_a?(GraphQL::Language::Nodes::InlineFragment)
-            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has inline fragments [#{ast_node.selections.map(&:type).map(&:name).join(", ")}])"
-          else
-            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has selections [#{ast_node.selections.map(&:name).join(", ")}])"
+        elsif !ast_node.selections.empty? && resolved_type.kind.leaf?
+          selection_strs = ast_node.selections.map do |n|
+            case n
+            when GraphQL::Language::Nodes::InlineFragment
+              "\"... on #{n.type.name} { ... }\""
+            when GraphQL::Language::Nodes::Field
+              "\"#{n.name}\""
+            when GraphQL::Language::Nodes::FragmentSpread
+              "\"#{n.name}\""
+            else
+              raise "Invariant: unexpected selection node: #{n}"
+            end
           end
+          "Selections can't be made on #{resolved_type.kind.name.sub("_", " ").downcase}s (%{node_name} returns #{resolved_type.graphql_name} but has selections [#{selection_strs.join(", ")}])"
         elsif resolved_type.kind.fields? && ast_node.selections.empty?
           "Field must have selections (%{node_name} returns #{resolved_type.graphql_name} but has no selections. Did you mean '#{ast_node.name} { ... }'?)"
         else

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

@@ -9,7 +9,8 @@ module GraphQL
       # without ambiguity.
       #
       # Original Algorithm: https://github.com/graphql/graphql-js/blob/master/src/validation/rules/OverlappingFieldsCanBeMerged.js
-      NO_ARGS = {}.freeze
+      NO_ARGS = GraphQL::EmptyObjects::EMPTY_HASH
+
       Field = Struct.new(:node, :definition, :owner_type, :parents)
       FragmentSpread = Struct.new(:name, :parents)
 
@@ -17,24 +18,47 @@ module GraphQL
         super
         @visited_fragments = {}
         @compared_fragments = {}
+        @conflict_count = 0
       end
 
       def on_operation_definition(node, _parent)
-        conflicts_within_selection_set(node, type_definition)
+        setting_errors { conflicts_within_selection_set(node, type_definition) }
         super
       end
 
       def on_field(node, _parent)
-        conflicts_within_selection_set(node, type_definition)
+        setting_errors { conflicts_within_selection_set(node, type_definition) }
         super
       end
 
       private
 
+      def field_conflicts
+        @field_conflicts ||= Hash.new do |errors, field|
+          errors[field] = GraphQL::StaticValidation::FieldsWillMergeError.new(kind: :field, field_name: field)
+        end
+      end
+
+      def arg_conflicts
+        @arg_conflicts ||= Hash.new do |errors, field|
+          errors[field] = GraphQL::StaticValidation::FieldsWillMergeError.new(kind: :argument, field_name: field)
+        end
+      end
+
+      def setting_errors
+        @field_conflicts = nil
+        @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) }
+      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: [])
+        fields, fragment_spreads = fields_and_fragments_from_selection(node, owner_type: parent_type, parents: nil)
 
         # (A) Find find all conflicts "within" the fields of this selection set.
         find_conflicts_within(fields)
@@ -93,8 +117,8 @@ module GraphQL
 
         return if fragment1.nil? || fragment2.nil?
 
-        fragment_type1 = context.warden.get_type(fragment1.type.name)
-        fragment_type2 = context.warden.get_type(fragment2.type.name)
+        fragment_type1 = context.query.types.type(fragment1.type.name)
+        fragment_type2 = context.query.types.type(fragment2.type.name)
 
         return if fragment_type1.nil? || fragment_type2.nil?
 
@@ -146,7 +170,7 @@ module GraphQL
         fragment = context.fragments[fragment_name]
         return if fragment.nil?
 
-        fragment_type = context.warden.get_type(fragment.type.name)
+        fragment_type = @types.type(fragment.type.name)
         return if fragment_type.nil?
 
         fragment_fields, fragment_spreads = fields_and_fragments_from_selection(fragment, owner_type: fragment_type, parents: [*fragment_spread.parents, fragment_type])
@@ -174,15 +198,22 @@ module GraphQL
         response_keys.each do |key, fields|
           next if fields.size < 2
           # find conflicts within nodes
-          for i in 0..fields.size - 1
-            for j in i + 1..fields.size - 1
+          i = 0
+          while i < fields.size
+            j = i + 1
+            while j < fields.size
               find_conflict(key, fields[i], fields[j])
+              j += 1
             end
+            i += 1
           end
         end
       end
 
       def find_conflict(response_key, field1, field2, mutually_exclusive: false)
+        return if @conflict_count >= context.max_errors
+        return if field1.definition.nil? || field2.definition.nil?
+
         node1 = field1.node
         node2 = field2.node
 
@@ -191,28 +222,21 @@ module GraphQL
 
         if !are_mutually_exclusive
           if node1.name != node2.name
-            errored_nodes = [node1.name, node2.name].sort.join(" or ")
-            msg = "Field '#{response_key}' has a field conflict: #{errored_nodes}?"
-            context.errors << GraphQL::StaticValidation::FieldsWillMergeError.new(
-              msg,
-              nodes: [node1, node2],
-              path: [],
-              field_name: response_key,
-              conflicts: errored_nodes
-            )
+            conflict = field_conflicts[response_key]
+
+            conflict.add_conflict(node1, node1.name)
+            conflict.add_conflict(node2, node2.name)
+
+            @conflict_count += 1
           end
 
           if !same_arguments?(node1, node2)
-            args = [serialize_field_args(node1), serialize_field_args(node2)]
-            conflicts = args.map { |arg| GraphQL::Language.serialize(arg) }.join(" or ")
-            msg = "Field '#{response_key}' has an argument conflict: #{conflicts}?"
-            context.errors << GraphQL::StaticValidation::FieldsWillMergeError.new(
-              msg,
-              nodes: [node1, node2],
-              path: [],
-              field_name: response_key,
-              conflicts: conflicts
-            )
+            conflict = arg_conflicts[response_key]
+
+            conflict.add_conflict(node1, GraphQL::Language.serialize(serialize_field_args(node1)))
+            conflict.add_conflict(node2, GraphQL::Language.serialize(serialize_field_args(node2)))
+
+            @conflict_count += 1
           end
         end
 
@@ -224,7 +248,9 @@ module GraphQL
       end
 
       def find_conflicts_between_sub_selection_sets(field1, field2, mutually_exclusive:)
-        return if field1.definition.nil? || field2.definition.nil?
+        return if field1.definition.nil? ||
+          field2.definition.nil? ||
+          (field1.node.selections.empty? && field2.node.selections.empty?)
 
         return_type1 = field1.definition.type.unwrap
         return_type2 = field2.definition.type.unwrap
@@ -298,12 +324,13 @@ module GraphQL
         end
       end
 
-      NO_SELECTIONS = [{}.freeze, [].freeze].freeze
+      NO_SELECTIONS = [GraphQL::EmptyObjects::EMPTY_HASH, GraphQL::EmptyObjects::EMPTY_ARRAY].freeze
 
       def fields_and_fragments_from_selection(node, owner_type:, parents:)
         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]
@@ -314,10 +341,10 @@ module GraphQL
         selections.each do |node|
           case node
           when GraphQL::Language::Nodes::Field
-            definition = context.schema.get_field(owner_type, node.name)
+            definition = @types.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
+            fragment_type = node.type ? @types.type(node.type.name) : owner_type
             find_fields_and_fragments(node.selections, parents: [*parents, fragment_type], owner_type: owner_type, fields: fields, fragment_spreads: fragment_spreads) if fragment_type
           when GraphQL::Language::Nodes::FragmentSpread
             fragment_spreads << FragmentSpread.new(node.name, parents)
@@ -370,7 +397,7 @@ module GraphQL
       end
 
       # Given two list of parents, find out if they are mutually exclusive
-      # In this context, `parents` represends the "self scope" of the field,
+      # In this context, `parents` represents the "self scope" of the field,
       # what types may be found at this point in the query.
       def mutually_exclusive?(parents1, parents2)
         if parents1.empty? || parents2.empty?
@@ -385,8 +412,8 @@ module GraphQL
               false
             else
               # Check if these two scopes have _any_ types in common.
-              possible_right_types = context.query.possible_types(type1)
-              possible_left_types = context.query.possible_types(type2)
+              possible_right_types = context.types.possible_types(type1)
+              possible_left_types = context.types.possible_types(type2)
               (possible_right_types & possible_left_types).empty?
             end
           end