graphql 2.5.9 → 2.5.26

data/lib/graphql/introspection/field_type.rb

@@ -7,22 +7,30 @@ module GraphQL
                   "a name, potentially a list of arguments, and a return type."
       field :name, String, null: false
       field :description, String
-      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false, scope: false do
+      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false, scope: false, resolve_each: :resolve_args do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
       field :type, GraphQL::Schema::LateBoundType.new("__Type"), null: false
-      field :is_deprecated, Boolean, null: false
+      field :is_deprecated, Boolean, null: false, resolve_each: :resolve_is_deprecated
       field :deprecation_reason, String
 
+      def self.resolve_is_deprecated(object, _context)
+        !!object.deprecation_reason
+      end
+
       def is_deprecated
-        !!@object.deprecation_reason
+        self.class.resolve_is_deprecated(object, context)
       end
 
-      def args(include_deprecated:)
-        args = @context.types.arguments(@object)
+      def self.resolve_args(object, context, include_deprecated:)
+        args = context.types.arguments(object)
         args = args.reject(&:deprecation_reason) unless include_deprecated
         args
       end
+
+      def args(include_deprecated:)
+        self.class.resolve_args(object, context, include_deprecated: include_deprecated)
+      end
     end
   end
 end

data/lib/graphql/introspection/input_value_type.rb

@@ -9,53 +9,61 @@ module GraphQL
       field :name, String, null: false
       field :description, String
       field :type, GraphQL::Schema::LateBoundType.new("__Type"), null: false
-      field :default_value, String, "A GraphQL-formatted string representing the default value for this input value."
-      field :is_deprecated, Boolean, null: false
+      field :default_value, String, "A GraphQL-formatted string representing the default value for this input value.", resolve_each: :resolve_default_value
+      field :is_deprecated, Boolean, null: false, resolve_each: :resolve_is_deprecated
       field :deprecation_reason, String
 
+      def self.resolve_is_deprecated(object, context)
+        !!object.deprecation_reason
+      end
+
       def is_deprecated
-        !!@object.deprecation_reason
+        self.class.resolve_is_deprecated(object, context)
       end
 
-      def default_value
-        if @object.default_value?
-          value = @object.default_value
+      def self.resolve_default_value(object, context)
+        if object.default_value?
+          value = object.default_value
           if value.nil?
             'null'
           else
-            if (@object.type.kind.list? || (@object.type.kind.non_null? && @object.type.of_type.kind.list?)) && !value.respond_to?(:map)
+            if (object.type.kind.list? || (object.type.kind.non_null? && object.type.of_type.kind.list?)) && !value.respond_to?(:map)
               # This is a bit odd -- we expect the default value to be an application-style value, so we use coerce result below.
               # But coerce_result doesn't wrap single-item lists, which are valid inputs to list types.
               # So, apply that wrapper here if needed.
               value = [value]
             end
-            coerced_default_value = @object.type.coerce_result(value, @context)
-            serialize_default_value(coerced_default_value, @object.type)
+            coerced_default_value = object.type.coerce_result(value, context)
+            serialize_default_value(coerced_default_value, object.type, context)
           end
         else
           nil
         end
       end
 
+      def default_value
+        self.class.resolve_default_value(object, context)
+      end
+
 
       private
 
       # Recursively serialize, taking care not to add quotes to enum values
-      def serialize_default_value(value, type)
+      def self.serialize_default_value(value, type, context)
         if value.nil?
           'null'
         elsif type.kind.list?
           inner_type = type.of_type
-          "[" + value.map { |v| serialize_default_value(v, inner_type) }.join(", ") + "]"
+          "[" + value.map { |v| serialize_default_value(v, inner_type, context) }.join(", ") + "]"
         elsif type.kind.non_null?
-          serialize_default_value(value, type.of_type)
+          serialize_default_value(value, type.of_type, context)
         elsif type.kind.enum?
           value
         elsif type.kind.input_object?
           "{" +
             value.map do |k, v|
               arg_defn = type.get_argument(k, context)
-              "#{k}: #{serialize_default_value(v, arg_defn.type)}"
+              "#{k}: #{serialize_default_value(v, arg_defn.type, context)}"
             end.join(", ") +
             "}"
         else

data/lib/graphql/introspection/type_type.rb

@@ -11,32 +11,36 @@ module GraphQL
                   "they describe. Abstract types, Union and Interface, provide the Object types "\
                   "possible at runtime. List and NonNull types compose other types."
 
-      field :kind, GraphQL::Schema::LateBoundType.new("__TypeKind"), null: false
+      field :kind, GraphQL::Schema::LateBoundType.new("__TypeKind"), null: false, resolve_each: :resolve_kind
       field :name, String, method: :graphql_name
       field :description, String
-      field :fields, [GraphQL::Schema::LateBoundType.new("__Field")], scope: false do
+      field :fields, [GraphQL::Schema::LateBoundType.new("__Field")], scope: false, resolve_each: :resolve_fields do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
-      field :interfaces, [GraphQL::Schema::LateBoundType.new("__Type")], scope: false
-      field :possible_types, [GraphQL::Schema::LateBoundType.new("__Type")], scope: false
-      field :enum_values, [GraphQL::Schema::LateBoundType.new("__EnumValue")], scope: false do
+      field :interfaces, [GraphQL::Schema::LateBoundType.new("__Type")], scope: false, resolve_each: :resolve_interfaces
+      field :possible_types, [GraphQL::Schema::LateBoundType.new("__Type")], scope: false, resolve_each: :resolve_possible_types
+      field :enum_values, [GraphQL::Schema::LateBoundType.new("__EnumValue")], scope: false, resolve_each: :resolve_enum_values do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
-      field :input_fields, [GraphQL::Schema::LateBoundType.new("__InputValue")], scope: false  do
+      field :input_fields, [GraphQL::Schema::LateBoundType.new("__InputValue")], scope: false, resolve_each: :resolve_input_fields  do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
-      field :of_type, GraphQL::Schema::LateBoundType.new("__Type")
+      field :of_type, GraphQL::Schema::LateBoundType.new("__Type"), resolve_each: :resolve_of_type
 
-      field :specifiedByURL, String, resolver_method: :specified_by_url
+      field :specifiedByURL, String, resolve_each: :resolve_specified_by_url, resolver_method: :specified_by_url
 
-      field :is_one_of, Boolean, null: false
+      field :is_one_of, Boolean, null: false, resolve_each: :resolve_is_one_of
 
-      def is_one_of
+      def self.resolve_is_one_of(object, _ctx)
         object.kind.input_object? &&
           object.directives.any? { |d| d.graphql_name == "oneOf" }
       end
 
-      def specified_by_url
+      def is_one_of
+        self.class.resolve_is_one_of(object, context)
+      end
+
+      def self.resolve_specified_by_url(object, _ctx)
         if object.kind.scalar?
           object.specified_by_url
         else
@@ -44,15 +48,23 @@ module GraphQL
         end
       end
 
+      def specified_by_url
+        self.class.resolve_specified_by_url(object, context)
+      end
+
+      def self.resolve_kind(object, context)
+        object.kind.name
+      end
+
       def kind
-        @object.kind.name
+        self.class.resolve_kind(object, context)
       end
 
-      def enum_values(include_deprecated:)
-        if !@object.kind.enum?
+      def self.resolve_enum_values(object, context, include_deprecated:)
+        if !object.kind.enum?
           nil
         else
-          enum_values = @context.types.enum_values(@object)
+          enum_values = context.types.enum_values(object)
 
           if !include_deprecated
             enum_values = enum_values.select {|f| !f.deprecation_reason }
@@ -62,17 +74,25 @@ module GraphQL
         end
       end
 
-      def interfaces
-        if @object.kind.object? || @object.kind.interface?
-          @context.types.interfaces(@object).sort_by(&:graphql_name)
+      def enum_values(include_deprecated:)
+        self.class.resolve_enum_values(object, context, include_deprecated: include_deprecated)
+      end
+
+      def self.resolve_interfaces(object, context)
+        if object.kind.object? || object.kind.interface?
+          context.types.interfaces(object).sort_by(&:graphql_name)
         else
           nil
         end
       end
 
-      def input_fields(include_deprecated:)
-        if @object.kind.input_object?
-          args = @context.types.arguments(@object)
+      def interfaces
+        self.class.resolve_interfaces(object, context)
+      end
+
+      def self.resolve_input_fields(object, context, include_deprecated:)
+        if object.kind.input_object?
+          args = context.types.arguments(object)
           args = args.reject(&:deprecation_reason) unless include_deprecated
           args
         else
@@ -80,19 +100,27 @@ module GraphQL
         end
       end
 
-      def possible_types
-        if @object.kind.abstract?
-          @context.types.possible_types(@object).sort_by(&:graphql_name)
+      def input_fields(include_deprecated:)
+        self.class.resolve_input_fields(object, context, include_deprecated: include_deprecated)
+      end
+
+      def self.resolve_possible_types(object, context)
+        if object.kind.abstract?
+          context.types.possible_types(object).sort_by(&:graphql_name)
         else
           nil
         end
       end
 
-      def fields(include_deprecated:)
-        if !@object.kind.fields?
+      def possible_types
+        self.class.resolve_possible_types(object, context)
+      end
+
+      def self.resolve_fields(object, context, include_deprecated:)
+        if !object.kind.fields?
           nil
         else
-          fields = @context.types.fields(@object)
+          fields = context.types.fields(object)
           if !include_deprecated
             fields = fields.select {|f| !f.deprecation_reason }
           end
@@ -100,8 +128,16 @@ module GraphQL
         end
       end
 
+      def fields(include_deprecated:)
+        self.class.resolve_fields(object, context, include_deprecated: include_deprecated)
+      end
+
+      def self.resolve_of_type(object, _ctx)
+        object.kind.wraps? ? object.of_type : nil
+      end
+
       def of_type
-        @object.kind.wraps? ? @object.of_type : nil
+        self.class.resolve_of_type(object, context)
       end
     end
   end

data/lib/graphql/invalid_null_error.rb

@@ -2,7 +2,7 @@
 module GraphQL
   # Raised automatically when a field's resolve function returns `nil`
   # for a non-null field.
-  class InvalidNullError < GraphQL::Error
+  class InvalidNullError < GraphQL::RuntimeError
     # @return [GraphQL::BaseType] The owner of {#field}
     attr_reader :parent_type
 
@@ -10,17 +10,23 @@ module GraphQL
     attr_reader :field
 
     # @return [GraphQL::Language::Nodes::Field] the field where the error occurred
-    attr_reader :ast_node
+    def ast_node
+      @ast_nodes.first
+    end
+
+    attr_reader :ast_nodes
 
     # @return [Boolean] indicates an array result caused the error
     attr_reader :is_from_array
 
-    def initialize(parent_type, field, ast_node, is_from_array: false)
+    attr_accessor :path
+
+    def initialize(parent_type, field, ast_node_or_nodes, is_from_array: false, path: nil)
       @parent_type = parent_type
       @field = field
-      @ast_node = ast_node
+      @ast_nodes = Array(ast_node_or_nodes)
       @is_from_array = is_from_array
-
+      @path = path
       # For List elements, identify the non-null error is for an
       # element and the required element type so it's not ambiguous
       # whether it was caused by a null instead of the list or a

data/lib/graphql/language/document_from_schema_definition.rb

@@ -52,8 +52,9 @@ module GraphQL
 
       def build_object_type_node(object_type)
         ints = @types.interfaces(object_type)
+
         if !ints.empty?
-          ints.sort_by!(&:graphql_name)
+          ints = ints.sort_by(&:graphql_name)
           ints.map! { |iface| build_type_name_node(iface) }
         end
 

data/lib/graphql/language/lexer.rb

@@ -20,10 +20,23 @@ module GraphQL
         @finished
       end
 
+      def freeze
+        @scanner = nil
+        super
+      end
+
       attr_reader :pos, :tokens_count
 
       def advance
-        @scanner.skip(IGNORE_REGEXP)
+        loop do
+          @scanner.skip(IGNORE_REGEXP)
+          if @scanner.skip(COMMENT_REGEXP)
+            @tokens_count += 1
+            next
+          end
+          break
+        end
+
         if @scanner.eos?
           @finished = true
           return false
@@ -173,12 +186,8 @@ module GraphQL
         raise GraphQL::ParseError.new(message, line, col, @string, filename: @filename)
       end
 
-      IGNORE_REGEXP = %r{
-        (?:
-          [, \c\r\n\t]+ |
-          \#.*$
-        )*
-      }x
+      IGNORE_REGEXP = /[, \c\r\n\t]+/
+      COMMENT_REGEXP = /\#[^\n]*/
       IDENTIFIER_REGEXP = /[_A-Za-z][_0-9A-Za-z]*/
       INT_REGEXP =        /-?(?:[0]|[1-9][0-9]*)/
       FLOAT_DECIMAL_REGEXP = /[.][0-9]+/
@@ -242,7 +251,7 @@ module GraphQL
         :SCALAR,
         nil,
         :FRAGMENT
-      ]
+      ].freeze
 
       # This produces a unique integer for bytes 2 and 3 of each keyword string
       # See https://tenderlovemaking.com/2023/09/02/fast-tokenizers-with-stringscanner.html
@@ -271,7 +280,8 @@ module GraphQL
       PUNCTUATION_NAME_FOR_BYTE = Punctuation.constants.each_with_object([]) { |name, arr|
         punct = Punctuation.const_get(name)
         arr[punct.ord] = name
-      }
+      }.freeze
+
 
       QUOTE =         '"'
       UNICODE_DIGIT = /[0-9A-Za-z]/
@@ -321,6 +331,7 @@ module GraphQL
         punct = Punctuation.const_get(punct_name)
         FIRST_BYTES[punct.ord] = ByteFor::PUNCTUATION
       end
+      FIRST_BYTES.freeze
 
 
       # Replace any escaped unicode or whitespace with the _actual_ characters

data/lib/graphql/language/nodes.rb

@@ -83,7 +83,11 @@ module GraphQL
 
         def to_query_string(printer: GraphQL::Language::Printer.new)
           if printer.is_a?(GraphQL::Language::Printer)
-            @query_string ||= printer.print(self)
+            if frozen?
+              @query_string || printer.print(self)
+            else
+              @query_string ||= printer.print(self)
+            end
           else
             printer.print(self)
           end

data/lib/graphql/language/parser.rb

@@ -2,6 +2,7 @@
 
 require "strscan"
 require "graphql/language/nodes"
+require "graphql/tracing/null_trace"
 
 module GraphQL
   module Language

data/lib/graphql/language.rb

@@ -77,21 +77,30 @@ module GraphQL
       new_query_str || query_str
     end
 
+    LEADING_REGEX = Regexp.union(" ", *Lexer::Punctuation.constants.map { |const| Lexer::Punctuation.const_get(const) })
+
+    # Optimized pattern using:
+    # - Possessive quantifiers (*+, ++) to prevent backtracking in number patterns
+    # - Atomic group (?>...) for IGNORE to prevent backtracking
+    # - Single unified number pattern instead of three alternatives
+    EFFICIENT_NUMBER_REGEXP = /-?(?:0|[1-9][0-9]*+)(?:\.[0-9]++)?(?:[eE][+-]?[0-9]++)?/
+    EFFICIENT_IGNORE_REGEXP = /(?>[, \r\n\t]+|\#[^\n]*$)*/
+
+    MAYBE_INVALID_NUMBER = /\d[_a-zA-Z]/
+
     INVALID_NUMBER_FOLLOWED_BY_NAME_REGEXP = %r{
-      (
-        ((?<num>#{Lexer::INT_REGEXP}(#{Lexer::FLOAT_EXP_REGEXP})?)(?<name>#{Lexer::IDENTIFIER_REGEXP})#{Lexer::IGNORE_REGEXP}:)
-        |
-        ((?<num>#{Lexer::INT_REGEXP}#{Lexer::FLOAT_DECIMAL_REGEXP}#{Lexer::FLOAT_EXP_REGEXP})(?<name>#{Lexer::IDENTIFIER_REGEXP})#{Lexer::IGNORE_REGEXP}:)
-        |
-        ((?<num>#{Lexer::INT_REGEXP}#{Lexer::FLOAT_DECIMAL_REGEXP})(?<name>#{Lexer::IDENTIFIER_REGEXP})#{Lexer::IGNORE_REGEXP}:)
-      )}x
+      (?<leading>#{LEADING_REGEX})
+      (?<num>#{EFFICIENT_NUMBER_REGEXP})
+      (?<name>#{Lexer::IDENTIFIER_REGEXP})
+      #{EFFICIENT_IGNORE_REGEXP}
+      :
+    }x
 
     def self.add_space_between_numbers_and_names(query_str)
-      if query_str.match?(INVALID_NUMBER_FOLLOWED_BY_NAME_REGEXP)
-        query_str.gsub(INVALID_NUMBER_FOLLOWED_BY_NAME_REGEXP, "\\k<num> \\k<name>:")
-      else
-        query_str
-      end
+      # Fast check for digit followed by identifier char. If this doesn't match, skip the more expensive regexp entirely.
+      return query_str unless query_str.match?(MAYBE_INVALID_NUMBER)
+      return query_str unless query_str.match?(INVALID_NUMBER_FOLLOWED_BY_NAME_REGEXP)
+      query_str.gsub(INVALID_NUMBER_FOLLOWED_BY_NAME_REGEXP, "\\k<leading>\\k<num> \\k<name>:")
     end
   end
 end

data/lib/graphql/pagination/connection.rb

@@ -94,6 +94,8 @@ module GraphQL
         @was_authorized_by_scope_items = detect_was_authorized_by_scope_items
       end
 
+      attr_writer :was_authorized_by_scope_items
+
       def was_authorized_by_scope_items?
         @was_authorized_by_scope_items
       end

data/lib/graphql/pagination/connections.rb

@@ -83,6 +83,38 @@ module GraphQL
         end
       end
 
+      def populate_connection(field, object, value, original_arguments, context)
+        if value.is_a? GraphQL::ExecutionError
+          # This isn't even going to work because context doesn't have ast_node anymore
+          context.add_error(value)
+          nil
+        elsif value.nil?
+          nil
+        elsif value.is_a?(GraphQL::Pagination::Connection)
+          # update the connection with some things that may not have been provided
+          value.context ||= context
+          value.parent ||= object
+          value.first_value ||= original_arguments[:first]
+          value.after_value ||= original_arguments[:after]
+          value.last_value ||= original_arguments[:last]
+          value.before_value ||= original_arguments[:before]
+          value.arguments ||= original_arguments # rubocop:disable Development/ContextIsPassedCop -- unrelated .arguments method
+          value.field ||= field
+          if field.has_max_page_size? && !value.has_max_page_size_override?
+            value.max_page_size = field.max_page_size
+          end
+          if field.has_default_page_size? && !value.has_default_page_size_override?
+            value.default_page_size = field.default_page_size
+          end
+          if (custom_t = context.schema.connections.edge_class_for_field(field))
+            value.edge_class = custom_t
+          end
+          value
+        else
+          context.namespace(:connections)[:all_wrappers] ||= context.schema.connections.all_wrappers
+          context.schema.connections.wrap(field, object, value, original_arguments, context)
+        end
+      end
       # use an override if there is one
       # @api private
       def edge_class_for_field(field)

data/lib/graphql/query/context.rb

@@ -29,6 +29,7 @@ module GraphQL
       end
 
       extend Forwardable
+      include Schema::Member::HasDataloader
 
       # @return [Array<GraphQL::ExecutionError>] errors returned during execution
       attr_reader :errors
@@ -84,7 +85,7 @@ module GraphQL
 
       attr_writer :types
 
-      RUNTIME_METADATA_KEYS = Set.new([:current_object, :current_arguments, :current_field, :current_path])
+      RUNTIME_METADATA_KEYS = Set.new([:current_object, :current_arguments, :current_field, :current_path]).freeze
       # @!method []=(key, value)
       #   Reassign `key` to the hash passed to {Schema#execute} as `context:`
 
@@ -111,20 +112,26 @@ module GraphQL
       # Return this value to tell the runtime
       # to exclude this field from the response altogether
       def skip
-        GraphQL::Execution::SKIP
+        GraphQL::Execution::Skip.new
       end
 
       # Add error at query-level.
       # @param error [GraphQL::ExecutionError] an execution error
       # @return [void]
       def add_error(error)
-        if !error.is_a?(ExecutionError)
-          raise TypeError, "expected error to be a ExecutionError, but was #{error.class}"
+        if !error.is_a?(GraphQL::RuntimeError)
+          raise TypeError, "expected error to be a GraphQL::RuntimeError, but was #{error.class}"
         end
         errors << error
         nil
       end
 
+      # @param value [Object] Any object to be inserted directly into the final response
+      # @return [GraphQL::Execution::Interpreter::RawValue] Return this from the field
+      def raw_value(value)
+        GraphQL::Execution::Interpreter::RawValue.new(value)
+      end
+
       # @example Print the GraphQL backtrace during field resolution
       #   puts ctx.backtrace
       #

data/lib/graphql/query/null_context.rb

@@ -4,7 +4,13 @@ module GraphQL
   class Query
     # This object can be `ctx` in places where there is no query
     class NullContext < Context
-      include Singleton
+      def self.instance
+        @instance ||= self.new
+      end
+
+      def self.instance=(new_inst)
+        @instance = new_inst
+      end
 
       class NullQuery
         def after_lazy(value)
@@ -20,10 +26,10 @@ module GraphQL
       attr_reader :schema, :query, :warden, :dataloader
       def_delegators GraphQL::EmptyObjects::EMPTY_HASH, :[], :fetch, :dig, :key?, :to_h
 
-      def initialize
+      def initialize(schema: NullSchema)
         @query = NullQuery.new
         @dataloader = GraphQL::Dataloader::NullDataloader.new
-        @schema = NullSchema
+        @schema = schema
         @warden = Schema::Warden::NullWarden.new(context: self, schema: @schema)
         @types = @warden.visibility_profile
         freeze

data/lib/graphql/query/partial.rb

@@ -32,6 +32,7 @@ module GraphQL
         @multiplex = nil
         @result_values = nil
         @result = nil
+        @finalizers = @top_level_finalizers = nil
 
         if fragment_node
           @ast_nodes = [fragment_node]
@@ -51,6 +52,10 @@ module GraphQL
         @leaf
       end
 
+      def root_value
+        object
+      end
+
       attr_reader :context, :query, :ast_nodes, :root_type, :object, :field_definition, :path, :schema
 
       attr_accessor :multiplex, :result_values
@@ -90,10 +95,22 @@ module GraphQL
         @query.fragments
       end
 
+      def validate
+        @query.validate
+      end
+
       def valid?
         @query.valid?
       end
 
+      def query?
+        true
+      end
+
+      def run_partials(...)
+        @query.run_partials(...)
+      end
+
       def analyzers
         EmptyObjects::EMPTY_ARRAY
       end
@@ -107,7 +124,7 @@ module GraphQL
       end
 
       def selected_operation
-        ast_nodes.first
+        Language::Nodes::OperationDefinition.new(selections: ast_nodes.flat_map(&:selections))
       end
 
       def static_errors
@@ -123,7 +140,6 @@ module GraphQL
       def set_type_info_from_path
         selections = [@query.selected_operation]
         type = @query.root_type
-        parent_type = nil
         field_defn = nil
 
         @path.each do |name_in_doc|
@@ -162,7 +178,6 @@ module GraphQL
           end
           field_name = next_selections.first.name
           field_defn = @schema.get_field(type, field_name, @query.context) || raise("Invariant: no field called #{field_name} on #{type.graphql_name}")
-          parent_type = type
           type = field_defn.type
           if type.non_null?
             type = type.of_type

data/lib/graphql/query.rb

@@ -159,6 +159,7 @@ module GraphQL
       @root_value = root_value
       @fragments = nil
       @operations = nil
+      @finalizers = @top_level_finalizers = nil
       @validate = validate
       self.static_validator = static_validator if static_validator
       context_tracers = (context ? context.fetch(:tracers, []) : [])
@@ -262,6 +263,10 @@ module GraphQL
       with_prepared_ast { @operations }
     end
 
+    def path
+      EmptyObjects::EMPTY_ARRAY
+    end
+
     # Run subtree partials of this query and return their results.
     # Each partial is identified with a `path:` and `object:`
     # where the path references a field in the AST and the object will be treated
@@ -271,7 +276,11 @@ module GraphQL
     # @return [Array<GraphQL::Query::Result>]
     def run_partials(partials_hashes)
       partials = partials_hashes.map { |partial_options| Partial.new(query: self, **partial_options) }
-      Execution::Interpreter.run_all(@schema, partials, context: @context)
+      if context[:__graphql_execute_next]
+        Execution::Next.run_all(@schema, partials, context: @context)
+      else
+        Execution::Interpreter.run_all(@schema, partials, context: @context)
+      end
     end
 
     # Get the result for this query, executing it once