graphql 2.5.11 → 2.6.10

data/lib/graphql/language/block_string.rb

@@ -21,17 +21,12 @@ module GraphQL
             next
           end
           line_length = line.size
-          line_indent = if line.match?(/\A  [^ ]/)
-            2
-          elsif line.match?(/\A    [^ ]/)
-            4
-          elsif line.match?(/\A[^ ]/)
-            0
-          else
-            line[/\A */].size
+          leading = 0
+          while leading < line_length && line.getbyte(leading) == 32
+            leading += 1
           end
-          if line_indent < line_length && (common_indent.nil? || line_indent < common_indent)
-            common_indent = line_indent
+          if leading < line_length && (common_indent.nil? || leading < common_indent)
+            common_indent = leading
           end
         end
 
@@ -41,7 +36,7 @@ module GraphQL
             if idx == 0
               next
             else
-              line.slice!(0, common_indent)
+              line[0, common_indent] = ""
             end
           end
         end

data/lib/graphql/language/cache.rb

@@ -2,6 +2,9 @@
 
 require 'graphql/version'
 require 'digest/sha2'
+require 'openssl'
+require 'securerandom'
+require 'tempfile'
 
 module GraphQL
   module Language
@@ -9,7 +12,11 @@ module GraphQL
     #
     # With Rails, parser caching may enabled by setting `config.graphql.parser_cache = true` in your Rails application.
     #
-    # The cache may be manually built by assigning `GraphQL::Language::Parser.cache = GraphQL::Language::Cache.new("some_dir")`.
+    # The cache may be manually built by assigning `GraphQL::Language::Parser.cache = GraphQL::Language::Cache.new(Pathname.new("some_dir"), secret: ENV.fetch("GRAPHQL_CACHE_SECRET"))`.
+    # The `secret` should be a stable value stored outside of the cache directory.
+    # When it isn't provided, a process-local secret is generated and cache entries
+    # are rebuilt after the process restarts. Pass `secret: nil` to disable cache
+    # signing. This should only be used when the cache directory is trusted.
     # This will create a directory (`tmp/cache/graphql` by default) that stores a cache of parsed files.
     #
     # Much like [bootsnap](https://github.com/Shopify/bootsnap), the parser cache needs to be cleaned up manually.
@@ -18,32 +25,95 @@ module GraphQL
     #
     # @see GraphQL::Railtie for simple Rails integration
     class Cache
-      def initialize(path)
+      # @param path [Pathname] The directory where cache entries are stored.
+      # @param secret [String, nil] A stable secret for verifying cache entries. When omitted,
+      #   a process-local secret is generated. Pass `nil` to disable cache signing.
+      def initialize(path, secret: SecureRandom.random_bytes(32))
         @path = path
+        @secret = secret
       end
 
       DIGEST = Digest::SHA256.new << GraphQL::VERSION
+      HMAC_SIZE = OpenSSL::Digest::SHA256.new.digest_length
+      InvalidCache = Class.new(StandardError)
+      private_constant :InvalidCache
 
       def fetch(filename)
-        hash = DIGEST.dup << filename
+        cache_key = cache_key_for(filename)
+        return yield unless cache_key
+
+        cache_path = @path.join(cache_key)
+
+        begin
+          return load_cache(cache_path, cache_key) if cache_path.file?
+        rescue InvalidCache, SystemCallError
+          # Rebuild caches created by older versions or with an invalid signature.
+        end
+
+        payload = yield
         begin
-          hash << File.mtime(filename).to_i.to_s
+          write_cache(cache_path, cache_key, payload)
         rescue SystemCallError
-          return yield
+          # Parser caching is best-effort; return the parsed payload if the cache cannot be written.
         end
-        cache_path = @path.join(hash.to_s)
+        payload
+      end
+
+      private
+
+      def cache_key_for(filename)
+        content_digest = Digest::SHA256.file(filename).hexdigest
+        (DIGEST.dup << filename << content_digest).to_s
+      rescue SystemCallError
+        nil
+      end
+
+      def load_cache(cache_path, cache_key)
+        cache_data = cache_path.binread
+        return Marshal.load(cache_data) unless @secret
+
+        signature = cache_data.byteslice(0, HMAC_SIZE)
+        payload = cache_data.byteslice(HMAC_SIZE..-1)
+        raise InvalidCache unless signature && payload
 
-        if cache_path.exist?
-          Marshal.load(cache_path.read)
+        expected_signature = signature_for(cache_key, payload)
+        unless secure_compare(signature, expected_signature)
+          raise InvalidCache
+        end
+        Marshal.load(payload)
+      end
+
+      def write_cache(cache_path, cache_key, payload)
+        @path.mkpath
+        serialized_payload = Marshal.dump(payload)
+        cache_data = if @secret
+          signature_for(cache_key, serialized_payload) + serialized_payload
         else
-          payload = yield
-          tmp_path = "#{cache_path}.#{rand}"
+          serialized_payload
+        end
+
+        Tempfile.create(['graphql-cache-', '.tmp'], @path.to_s) do |tempfile|
+          tempfile.binmode
+          tempfile.write(cache_data)
+          tempfile.flush
+          tempfile.fsync
+          tempfile.close
+          File.rename(tempfile.path, cache_path.to_s)
+        end
+      end
+
+      def signature_for(cache_key, payload)
+        OpenSSL::HMAC.digest('SHA256', @secret, cache_key + payload)
+      end
+
+      def secure_compare(left, right)
+        return false unless left.bytesize == right.bytesize
 
-          @path.mkpath
-          File.binwrite(tmp_path, Marshal.dump(payload))
-          File.rename(tmp_path, cache_path.to_s)
-          payload
+        result = 0
+        left.bytes.each_with_index do |byte, index|
+          result |= byte ^ right.getbyte(index)
         end
+        result.zero?
       end
     end
   end

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

@@ -9,6 +9,9 @@ module GraphQL
         end
         @string = graphql_str
         @filename = filename
+        if !@string.valid_encoding?
+          raise_parse_error("Parse error on bad Unicode escape sequence", nil, nil)
+        end
         @scanner = StringScanner.new(graphql_str)
         @pos = nil
         @max_tokens = max_tokens || Float::INFINITY
@@ -28,7 +31,15 @@ module GraphQL
       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
@@ -102,10 +113,6 @@ module GraphQL
           @scanner.pos += 1
           :UNKNOWN_CHAR
         end
-      rescue ArgumentError => err
-        if err.message == "invalid byte sequence in UTF-8"
-          raise_parse_error("Parse error on bad Unicode escape sequence", nil, nil)
-        end
       end
 
       def token_value
@@ -122,7 +129,7 @@ module GraphQL
         elsif token_name == :STRING
           string_value
         elsif @scanner.matched_size.nil?
-          @scanner.peek(1)
+          @string.byteslice(@scanner.pos - 1, 1)
         else
           token_value
         end
@@ -139,7 +146,7 @@ module GraphQL
         "\\r" => "\r",
         "\\t" => "\t",
       }
-      UTF_8 = /\\u(?:([\dAa-f]{4})|\{([\da-f]{4,})\})(?:\\u([\dAa-f]{4}))?/i
+      UTF_8 = /\\u(?:([\da-f]{4})|\{([\da-f]+)\})(?:\\u([\da-f]{4}))?/i
       VALID_STRING = /\A(?:[^\\]|#{ESCAPES}|#{UTF_8})*\z/o
       ESCAPED = /(?:#{ESCAPES}|#{UTF_8})/o
 
@@ -155,7 +162,11 @@ module GraphQL
           if !str.valid_encoding? || !str.match?(VALID_STRING)
             raise_parse_error("Bad unicode escape in #{str.inspect}")
           else
-            Lexer.replace_escaped_characters_in_place(str)
+            begin
+              Lexer.replace_escaped_characters_in_place(str)
+            rescue RangeError
+              raise_parse_error("Bad unicode escape in #{str.inspect}")
+            end
 
             if !str.valid_encoding?
               raise_parse_error("Bad unicode escape in #{str.inspect}")
@@ -167,23 +178,22 @@ module GraphQL
       end
 
       def line_number
-        @scanner.string[0..@pos].count("\n") + 1
+        @scanner.string.byteslice(0, @pos).b.count("\n".b) + 1
       end
 
       def column_number
-        @scanner.string[0..@pos].split("\n").last.length
+        line_prefix = @scanner.string.byteslice(0, @pos)
+        line_prefix = line_prefix.b unless line_prefix.valid_encoding?
+        newline_index = line_prefix.rindex("\n")
+        newline_index ? line_prefix.length - newline_index : line_prefix.length + 1
       end
 
       def raise_parse_error(message, line = line_number, col = column_number)
         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]+/
@@ -282,7 +292,7 @@ module GraphQL
       QUOTE =         '"'
       UNICODE_DIGIT = /[0-9A-Za-z]/
       FOUR_DIGIT_UNICODE = /#{UNICODE_DIGIT}{4}/
-      N_DIGIT_UNICODE = %r{#{Punctuation::LCURLY}#{UNICODE_DIGIT}{4,}#{Punctuation::RCURLY}}x
+      N_DIGIT_UNICODE = %r{#{Punctuation::LCURLY}#{UNICODE_DIGIT}+#{Punctuation::RCURLY}}x
       UNICODE_ESCAPE = %r{\\u(?:#{FOUR_DIGIT_UNICODE}|#{N_DIGIT_UNICODE})}
       STRING_ESCAPE = %r{[\\][\\/bfnrt]}
       BLOCK_QUOTE =   '"""'

data/lib/graphql/language/nodes.rb

@@ -304,7 +304,8 @@ module GraphQL
                 children_method_names.map { |m| "#{m}: NO_CHILDREN" } +
                 DEFAULT_INITIALIZE_OPTIONS
 
-              assignments = scalar_method_names.map { |m| "@#{m} = #{m}"} +
+              # Intern descriptions so identical strings across SDL documents share one frozen object.
+              assignments = scalar_method_names.map { |m| m == :description ? "@#{m} = #{m} && -#{m}" : "@#{m} = #{m}" } +
                 children_method_names.map { |m| "@#{m} = #{m}.freeze" }
 
               if name.end_with?("Definition") && name != "FragmentDefinition"

data/lib/graphql/language/parser.rb

@@ -806,7 +806,7 @@ module GraphQL
 
       def expect_token(expected_token_name)
         unless @token_name == expected_token_name
-          raise_parse_error("Expected #{expected_token_name}, actual: #{token_name || "(none)"} (#{debug_token_value.inspect})")
+          raise_parse_error("Expected #{expected_token_name}, #{@token_name == false ? "not end of file" : "actual: #{@token_name} (#{debug_token_value.inspect})"}")
         end
         advance_token
       end

data/lib/graphql/language.rb

@@ -31,11 +31,11 @@ module GraphQL
 
         "[#{serialized_array}]"
       else
-        JSON.generate(value, quirks_mode: true)
+        JSON.generate(value)
       end
     rescue JSON::GeneratorError
-      if Float::INFINITY == value
-        "Infinity"
+      if value.is_a?(Float) && !value.finite?
+        value.to_s
       else
         raise
       end
@@ -47,13 +47,19 @@ module GraphQL
     def self.escape_single_quoted_newlines(query_str)
       scanner = StringScanner.new(query_str)
       inside_single_quoted_string = false
+      inside_triple_quoted_string = false
       new_query_str = nil
       while !scanner.eos?
-        if scanner.skip(/(?:\\"|[^"\n\r]|""")+/m)
+        if scanner.skip('"""')
+          inside_triple_quoted_string = !inside_triple_quoted_string
+          new_query_str && (new_query_str << scanner.matched)
+        elsif scanner.skip(/(?:\\"|[^"\n\r])+/m)
           new_query_str && (new_query_str << scanner.matched)
         elsif scanner.skip('"')
           new_query_str && (new_query_str << '"')
-          inside_single_quoted_string = !inside_single_quoted_string
+          if !inside_triple_quoted_string
+            inside_single_quoted_string = !inside_single_quoted_string
+          end
         elsif scanner.skip("\n")
           if inside_single_quoted_string
             new_query_str ||= query_str[0, scanner.pos - 1]
@@ -77,21 +83,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,36 @@ module GraphQL
         end
       end
 
+      def populate_connection(field, object, value, original_arguments, context)
+        if value.is_a? GraphQL::ExecutionError
+          raise value
+        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/pagination/relation_connection.rb

@@ -221,7 +221,16 @@ module GraphQL
       # returns an array of nodes
       def load_nodes
         # Return an array so we can consistently use `.index(node)` on it
-        @nodes ||= limited_nodes.to_a
+        return @nodes if @nodes
+        if (@context[:dataloader].is_a?(GraphQL::Dataloader::AsyncDataloader))
+          # `AsyncDataloader` may resolve sibling fields (eg, `edges` and `pageInfo`)
+          # in separate Fibers, so several callers can get here before `@nodes` is set.
+          (@load_lock ||= Mutex.new).synchronize do
+            @nodes ||= limited_nodes.to_a
+          end
+        else
+          @nodes = limited_nodes.to_a
+        end
       end
     end
   end

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
@@ -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/variable_validation_error.rb

@@ -22,7 +22,7 @@ module GraphQL
         # It is possible there are other extension items in this error, so handle
         # a one level deep merge explicitly. However beyond that only show the
         # latest value and problems.
-        super.merge({ "extensions" => { "value" => value, "problems" => validation_result.problems }}) do |key, oldValue, newValue|
+        super.merge({ "extensions" => { "value" => value_for_extensions, "problems" => validation_result.problems }}) do |key, oldValue, newValue|
           if oldValue.respond_to?(:merge)
             oldValue.merge(newValue)
           else
@@ -33,6 +33,21 @@ module GraphQL
 
       private
 
+      def value_for_extensions(value = @value)
+        case value
+        when Array
+          value.map { |item| value_for_extensions(item) }
+        when Hash
+          value.each_with_object({}) do |(key, item), result|
+            result[key] = value_for_extensions(item)
+          end
+        when Float
+          value.finite? ? value : value.to_s
+        else
+          value
+        end
+      end
+
       def problem_fields
         @problem_fields ||= @validation_result
           .problems

data/lib/graphql/query/variables.rb

@@ -19,7 +19,7 @@ module GraphQL
         @storage = ast_variables.each_with_object({}) do |ast_variable, memo|
           if schema.validate_max_errors && schema.validate_max_errors <= @errors.count
             add_max_errors_reached_message
-            break
+            break memo
           end
           # Find the right value for this variable:
           # - First, use the value provided at runtime

data/lib/graphql/query.rb

@@ -45,8 +45,8 @@ module GraphQL
       end
 
       # @api private
-      def handle_or_reraise(err)
-        @schema.handle_or_reraise(context, err)
+      def handle_or_reraise(err, **kwargs)
+        @schema.handle_or_reraise(context, err, **kwargs)
       end
     end
 
@@ -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