graphql 2.5.11 → 2.6.10

data/lib/graphql/execution/interpreter/runtime.rb

@@ -35,11 +35,10 @@ module GraphQL
         # @return [GraphQL::Query::Context]
         attr_reader :context
 
-        def initialize(query:, lazies_at_depth:)
+        def initialize(query:)
           @query = query
           @current_trace = query.current_trace
           @dataloader = query.multiplex.dataloader
-          @lazies_at_depth = lazies_at_depth
           @schema = query.schema
           @context = query.context
           @response = nil
@@ -199,7 +198,7 @@ module GraphQL
 
         def each_gathered_selections(response_hash)
           ordered_result_keys = []
-          gathered_selections = gather_selections(response_hash.graphql_application_value, response_hash.graphql_result_type, response_hash.graphql_selections, nil, {}, ordered_result_keys)
+          gathered_selections = gather_selections(response_hash, response_hash.graphql_application_value, response_hash.graphql_result_type, response_hash.graphql_selections, nil, {}, ordered_result_keys)
           ordered_result_keys.uniq!
           if gathered_selections.is_a?(Array)
             gathered_selections.each do |item|
@@ -210,15 +209,13 @@ module GraphQL
           end
         end
 
-        def gather_selections(owner_object, owner_type, selections, selections_to_run, selections_by_name, ordered_result_keys)
+        def gather_selections(graphql_response, owner_object, owner_type, selections, selections_to_run, selections_by_name, ordered_result_keys)
           selections.each do |node|
-            # Skip gathering this if the directive says so
-            if !directives_include?(node, owner_object, owner_type)
-              next
-            end
-
             if node.is_a?(GraphQL::Language::Nodes::Field)
               response_key = node.alias || node.name
+              if !directives_include?(node, owner_object, owner_type, graphql_response, response_key)
+                next
+              end
               ordered_result_keys << response_key
               selections = selections_by_name[response_key]
               # if there was already a selection of this field,
@@ -235,6 +232,9 @@ module GraphQL
                 selections_by_name[response_key] = node
               end
             else
+              if !directives_include?(node, owner_object, owner_type, graphql_response, nil)
+                next
+              end
               # This is an InlineFragment or a FragmentSpread
               if !@runtime_directive_names.empty? && node.directives.any? { |d| @runtime_directive_names.include?(d.name) }
                 next_selections = {}
@@ -256,14 +256,14 @@ module GraphQL
                   type_defn = query.types.type(node.type.name)
 
                   if query.types.possible_types(type_defn).include?(owner_type)
-                    result = gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections, ordered_result_keys)
+                    result = gather_selections(graphql_response, owner_object, owner_type, node.selections, selections_to_run, next_selections, ordered_result_keys)
                     if !result.equal?(next_selections)
                       selections_to_run = result
                     end
                   end
                 else
                   # it's an untyped fragment, definitely continue
-                  result = gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections, ordered_result_keys)
+                  result = gather_selections(graphql_response, owner_object, owner_type, node.selections, selections_to_run, next_selections, ordered_result_keys)
                   if !result.equal?(next_selections)
                     selections_to_run = result
                   end
@@ -272,7 +272,7 @@ module GraphQL
                 fragment_def = query.fragments[node.name]
                 type_defn = query.types.type(fragment_def.type.name)
                 if query.types.possible_types(type_defn).include?(owner_type)
-                  result = gather_selections(owner_object, owner_type, fragment_def.selections, selections_to_run, next_selections, ordered_result_keys)
+                  result = gather_selections(graphql_response, owner_object, owner_type, fragment_def.selections, selections_to_run, next_selections, ordered_result_keys)
                   if !result.equal?(next_selections)
                     selections_to_run = result
                   end
@@ -340,7 +340,7 @@ module GraphQL
           end
           field_name = ast_node.name
           owner_type = selections_result.graphql_result_type
-          field_defn = query.types.field(owner_type, field_name)
+          field_defn = query.types.field(owner_type, field_name) || raise(GraphQL::Error, "No field definition found for #{owner_type.graphql_name}.#{field_name} (at #{ast_node.position})")
 
           # Set this before calling `run_with_directives`, so that the directive can have the latest path
           runtime_state = get_current_runtime_state
@@ -365,6 +365,10 @@ module GraphQL
           else
             @query.arguments_cache.dataload_for(ast_node, field_defn, owner_object) do |resolved_arguments|
               runtime_state = get_current_runtime_state # This might be in a different fiber
+              runtime_state.current_field = field_defn
+              runtime_state.current_arguments = resolved_arguments
+              runtime_state.current_result_name = result_name
+              runtime_state.current_result = selections_result
               evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_object, result_name, selections_result, runtime_state)
             end
           end
@@ -373,6 +377,8 @@ module GraphQL
         def evaluate_selection_with_args(arguments, field_defn, ast_node, field_ast_nodes, object, result_name, selection_result, runtime_state)  # rubocop:disable Metrics/ParameterLists
           after_lazy(arguments, field: field_defn, ast_node: ast_node, owner_object: object, arguments: arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |resolved_arguments, runtime_state|
             if resolved_arguments.is_a?(GraphQL::ExecutionError) || resolved_arguments.is_a?(GraphQL::UnauthorizedError)
+              next if selection_result.collect_result(result_name, resolved_arguments)
+
               return_type_non_null = field_defn.type.non_null?
               continue_value(resolved_arguments, field_defn, return_type_non_null, ast_node, result_name, selection_result)
               next
@@ -446,7 +452,7 @@ module GraphQL
             }
           end
 
-          field_result = call_method_on_directives(:resolve, object, directives) do
+          call_method_on_directives(:resolve, object, directives) do
             if !directives.empty?
               # This might be executed in a different context; reset this info
               runtime_state = get_current_runtime_state
@@ -472,6 +478,8 @@ module GraphQL
             end
             @current_trace.end_execute_field(field_defn, object, kwarg_arguments, query, app_result)
             after_lazy(app_result, field: field_defn, ast_node: ast_node, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |inner_result, runtime_state|
+              next if selection_result.collect_result(result_name, inner_result)
+
               owner_type = selection_result.graphql_result_type
               return_type = field_defn.type
               continue_value = continue_value(inner_result, field_defn, return_type.non_null?, ast_node, result_name, selection_result)
@@ -484,12 +492,6 @@ module GraphQL
               end
             end
           end
-          # If this field is a root mutation field, immediately resolve
-          # all of its child fields before moving on to the next root mutation field.
-          # (Subselections of this mutation will still be resolved level-by-level.)
-          if selection_result.graphql_is_eager
-            Interpreter::Resolve.resolve_all([field_result], @dataloader)
-          end
         end
 
         def set_result(selection_result, result_name, value, is_child_result, is_non_null)
@@ -572,7 +574,7 @@ module GraphQL
                 value.path ||= current_path
                 value.ast_node ||= ast_node
                 context.errors << value
-                if selection_result
+                if selection_result && result_name
                   set_result(selection_result, result_name, nil, false, is_non_null)
                 end
               end
@@ -596,7 +598,7 @@ module GraphQL
                 err
               end
               continue_value(next_value, field, is_non_null, ast_node, result_name, selection_result)
-            elsif GraphQL::Execution::SKIP == value
+            elsif value.is_a?(GraphQL::Execution::Skip)
               # It's possible a lazy was already written here
               case selection_result
               when GraphQLResultHash
@@ -667,7 +669,11 @@ module GraphQL
             rescue GraphQL::ExecutionError => ex_err
               return continue_value(ex_err, field, is_non_null, ast_node, result_name, selection_result)
             rescue StandardError => err
-              query.handle_or_reraise(err)
+              begin
+                query.handle_or_reraise(err)
+              rescue GraphQL::ExecutionError => ex_err
+                return continue_value(ex_err, field, is_non_null, ast_node, result_name, selection_result)
+              end
             end
             set_result(selection_result, result_name, r, false, is_non_null)
             r
@@ -750,7 +756,7 @@ module GraphQL
                   idx += 1
                   if use_dataloader_job
                     @dataloader.append_job do
-                      resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state)
+                      resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, nil)
                     end
                   else
                     resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state)
@@ -759,8 +765,7 @@ module GraphQL
 
                 response_list
               rescue NoMethodError => err
-                # Ruby 2.2 doesn't have NoMethodError#receiver, can't check that one in this case. (It's been EOL since 2017.)
-                if err.name == :each && (err.respond_to?(:receiver) ? err.receiver == value : true)
+                if err.name == :each && err.receiver == value
                   # This happens when the GraphQL schema doesn't match the implementation. Help the dev debug.
                   raise ListResultFailedError.new(value: value, field: field, path: current_path)
                 else
@@ -792,6 +797,7 @@ module GraphQL
         end
 
         def resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state) # rubocop:disable Metrics/ParameterLists
+          runtime_state ||= get_current_runtime_state
           runtime_state.current_result_name = this_idx
           runtime_state.current_result = response_list
           call_method_on_directives(:resolve_each, owner_object, ast_node.directives) do
@@ -844,11 +850,31 @@ module GraphQL
         end
 
         # Check {Schema::Directive.include?} for each directive that's present
-        def directives_include?(node, graphql_object, parent_type)
+        def directives_include?(node, graphql_object, parent_type, selection_result, extra_path_part)
           node.directives.each do |dir_node|
             dir_defn = @schema_directives.fetch(dir_node.name)
-            args = arguments(graphql_object, dir_defn, dir_node)
-            if !dir_defn.include?(graphql_object, args, context)
+            raw_dir_args = arguments(nil, dir_defn, dir_node)
+            if !raw_dir_args.is_a?(GraphQL::ExecutionError)
+              begin
+                dir_defn.validate!(raw_dir_args, context)
+              rescue GraphQL::ExecutionError => err
+                raw_dir_args = err
+              end
+            end
+
+            if extra_path_part && raw_dir_args.is_a?(GraphQL::ExecutionError)
+              raw_dir_args.path = current_path + [extra_path_part]
+            end
+
+            dir_args = continue_value(
+              raw_dir_args, # value
+              nil, # field
+              false, # is_non_null
+              dir_node, # ast_node
+              nil, # result_name
+              selection_result
+            )
+            if dir_args == HALT || !dir_defn.include?(graphql_object, dir_args, context)
               return false
             end
           end
@@ -879,7 +905,6 @@ module GraphQL
         # @return [GraphQL::Execution::Lazy, Object] If loading `object` will be deferred, it's a wrapper over it.
         def after_lazy(lazy_obj, field:, owner_object:, arguments:, ast_node:, result:, result_name:, eager: false, runtime_state:, trace: true, &block)
           if lazy?(lazy_obj)
-            orig_result = result
             was_authorized_by_scope_items = runtime_state.was_authorized_by_scope_items
             lazy = GraphQL::Execution::Lazy.new(field: field) do
               # This block might be called in a new fiber;
@@ -889,13 +914,13 @@ module GraphQL
               runtime_state.current_field = field
               runtime_state.current_arguments = arguments
               runtime_state.current_result_name = result_name
-              runtime_state.current_result = orig_result
+              runtime_state.current_result = result
               runtime_state.was_authorized_by_scope_items = was_authorized_by_scope_items
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
-              result = nil
+              sync_result = nil
               inner_obj = begin
-                result = if trace
+                sync_result = if trace
                   @current_trace.begin_execute_field(field, owner_object, arguments, query)
                   @current_trace.execute_field_lazy(field: field, query: query, object: owner_object, arguments: arguments, ast_node: ast_node) do
                     schema.sync_lazy(lazy_obj)
@@ -913,7 +938,7 @@ module GraphQL
                 end
               ensure
                 if trace
-                  @current_trace.end_execute_field(field, owner_object, arguments, query, result)
+                  @current_trace.end_execute_field(field, owner_object, arguments, query, sync_result)
                 end
               end
               yield(inner_obj, runtime_state)
@@ -923,12 +948,7 @@ module GraphQL
               lazy.value
             else
               set_result(result, result_name, lazy, false, false) # is_non_null is irrelevant here
-              current_depth = 0
-              while result
-                current_depth += 1
-                result = result.graphql_parent
-              end
-              @lazies_at_depth[current_depth] << lazy
+              @dataloader.lazy_at_depth(result.depth, lazy)
               lazy
             end
           else

data/lib/graphql/execution/interpreter.rb

@@ -22,6 +22,7 @@ module GraphQL
         # @param max_complexity [Integer, nil]
         # @return [Array<GraphQL::Query::Result>] One result per query
         def run_all(schema, query_options, context: {}, max_complexity: schema.max_complexity)
+          previous_multiplex = Fiber[:__graphql_current_multiplex]
           queries = query_options.map do |opts|
             query = case opts
             when Hash
@@ -42,7 +43,6 @@ module GraphQL
           trace.execute_multiplex(multiplex: multiplex) do
             schema = multiplex.schema
             queries = multiplex.queries
-            lazies_at_depth = Hash.new { |h, k| h[k] = [] }
             multiplex_analyzers = schema.multiplex_analyzers
             if multiplex.max_complexity
               multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity]
@@ -59,11 +59,6 @@ module GraphQL
               # Do as much eager evaluation of the query as possible
               results = []
               queries.each_with_index do |query, idx|
-                if query.subscription? && !query.subscription_update?
-                  subs_namespace = query.context.namespace(:subscriptions)
-                  subs_namespace[:events] = []
-                  subs_namespace[:subscriptions] = {}
-                end
                 multiplex.dataloader.append_job {
                   operation = query.selected_operation
                   result = if operation.nil? || !query.valid? || !query.context.errors.empty?
@@ -73,38 +68,27 @@ module GraphQL
                       # Although queries in a multiplex _share_ an Interpreter instance,
                       # they also have another item of state, which is private to that query
                       # in particular, assign it here:
-                      runtime = Runtime.new(query: query, lazies_at_depth: lazies_at_depth)
+                      runtime = Runtime.new(query: query)
                       query.context.namespace(:interpreter_runtime)[:runtime] = runtime
-
+                      if query.subscription? && !query.subscription_update?
+                        schema.subscriptions.initialize_subscriptions(query)
+                      end
                       query.current_trace.execute_query(query: query) do
                         runtime.run_eager
                       end
                     rescue GraphQL::ExecutionError => err
                       query.context.errors << err
-                      NO_OPERATION
                     end
                   end
                   results[idx] = result
                 }
               end
 
-              multiplex.dataloader.run
-
-              # Then, work through lazy results in a breadth-first way
-              multiplex.dataloader.append_job {
-                query = multiplex.queries.length == 1 ? multiplex.queries[0] : nil
-                multiplex.current_trace.execute_query_lazy(multiplex: multiplex, query: query) do
-                  Interpreter::Resolve.resolve_each_depth(lazies_at_depth, multiplex.dataloader)
-                end
-              }
-              multiplex.dataloader.run
+              multiplex.dataloader.run(trace_query_lazy: multiplex)
 
               # Then, find all errors and assign the result to the query object
               results.each_with_index do |data_result, idx|
                 query = queries[idx]
-                if (events = query.context.namespace(:subscriptions)[:events]) && !events.empty?
-                  schema.subscriptions.write_subscription(query, events)
-                end
                 # Assign the result so that it can be accessed in instrumentation
                 query.result_values = if data_result.equal?(NO_OPERATION)
                   if !query.valid? || !query.context.errors.empty?
@@ -114,6 +98,9 @@ module GraphQL
                     data_result
                   end
                 else
+                  if query.subscription?
+                    schema.subscriptions.finish_subscriptions(query)
+                  end
                   result = {}
 
                   if !query.context.errors.empty?
@@ -133,13 +120,18 @@ module GraphQL
               end
 
               results
+            rescue SystemStackError => err
+              queries.map do |query|
+                schema.query_stack_error(query, err)
+                query.result_values ||= { "errors" => query.context.errors.map(&:to_h) }
+                query.result
+              end
             rescue Exception
               # TODO rescue at a higher level so it will catch errors in analysis, too
               # Assign values here so that the query's `@executed` becomes true
               queries.map { |q| q.result_values ||= {} }
               raise
             ensure
-              Fiber[:__graphql_current_multiplex] = nil
               queries.map { |query|
                 runtime = query.context.namespace(:interpreter_runtime)[:runtime]
                 if runtime
@@ -148,6 +140,8 @@ module GraphQL
               }
             end
           end
+        ensure
+          Fiber[:__graphql_current_multiplex] = previous_multiplex
         end
       end
 

data/lib/graphql/execution/lazy.rb

@@ -38,7 +38,7 @@ module GraphQL
         # (fewer clauses in a hot `case` block), but now it requires special handling here.
         # I think it's still worth it for the performance win, but if the number of special
         # cases grows, then maybe it's worth rethinking somehow.
-        if @value.is_a?(StandardError) && @value != GraphQL::Execution::SKIP
+        if @value.is_a?(StandardError) && !@value.is_a?(GraphQL::Execution::Skip)
           raise @value
         else
           @value

data/lib/graphql/execution/load_argument_step.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    class LoadArgumentStep
+      def initialize(field_resolve_step:, arguments:, load_receiver:, argument_value:, argument_definition:, argument_key:)
+        @field_resolve_step = field_resolve_step
+        @load_receiver = load_receiver
+        @arguments = arguments
+        @argument_value = argument_value
+        @argument_definition = argument_definition
+        @argument_key = argument_key
+        @loaded_value = nil
+        @is_authorized = true
+      end
+
+      def value
+        @field_resolve_step.set_current_field
+        schema = @field_resolve_step.runner.schema
+        @loaded_value = schema.sync_lazy(@loaded_value)
+        assign_value
+      rescue GraphQL::UnauthorizedError => auth_err
+        @is_authorized = false
+        schema.unauthorized_object(auth_err)
+      rescue GraphQL::RuntimeError => err
+        @loaded_value = if err.is_a?(Schema::Subscription::EarlyUnsubscribe)
+          err.unsubscribed_result
+        else
+          err
+        end
+        assign_value
+      rescue StandardError => stderr
+        begin
+          @field_resolve_step.selections_step.query.handle_or_reraise(stderr, field: @field_definition, arguments: @arguments, object: nil)
+        rescue GraphQL::ExecutionError => ex_err
+          @loaded_value = ex_err
+        end
+        assign_value
+      ensure
+        @field_resolve_step.set_current_field(nil)
+      end
+
+      def call
+        @field_resolve_step.set_current_field
+        context = @field_resolve_step.selections_step.query.context
+        @loaded_value = begin
+          @load_receiver.load_and_authorize_application_object(@argument_definition, @argument_value, context)
+        rescue GraphQL::UnauthorizedError => auth_err
+          @is_authorized = false
+          context.schema.unauthorized_object(auth_err)
+        end
+        if (runner = @field_resolve_step.runner).resolves_lazies && runner.lazy?(@loaded_value)
+          runner.dataloader.lazy_at_depth(@field_resolve_step.path.size, self)
+        else
+          assign_value
+        end
+      rescue GraphQL::RuntimeError => err
+        @loaded_value = if err.is_a?(Schema::Subscription::EarlyUnsubscribe)
+          @is_authorized = false
+          err.unsubscribed_result
+        else
+          err
+        end
+        assign_value
+      rescue StandardError => stderr
+        @loaded_value = begin
+          context.query.handle_or_reraise(stderr, field: @field_resolve_step.field_definition, arguments: @field_resolve_step.arguments, object: nil) # rubocop:disable Development/ContextIsPassedCop
+        rescue GraphQL::ExecutionError => ex_err
+          ex_err
+        end
+        assign_value
+      ensure
+        @field_resolve_step.set_current_field(nil)
+      end
+
+      private
+
+      def assign_value
+        if @loaded_value.is_a?(GraphQL::RuntimeError)
+          @loaded_value.path = @field_resolve_step.path
+          @field_resolve_step.arguments = @loaded_value
+        elsif @is_authorized == false
+          # An unauthorized_object hook ate the error
+          @field_resolve_step.arguments = EmptyObjects::EMPTY_HASH
+          field_pending_steps = @field_resolve_step.pending_steps
+          field_pending_steps.clear
+          @field_resolve_step.build_errors_result(nil, nil)
+          return
+        else
+          query = @field_resolve_step.selections_step.query
+          query.current_trace.object_loaded(@argument_definition, @loaded_value, query.context)
+          @arguments[@argument_key] = @loaded_value
+        end
+
+        field_pending_steps = @field_resolve_step.pending_steps
+        field_pending_steps.delete(self)
+        if @field_resolve_step.arguments && field_pending_steps.size == 0 # rubocop:disable Development/ContextIsPassedCop
+          @field_resolve_step.runner.add_step(@field_resolve_step)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/multiplex.rb

@@ -33,7 +33,7 @@ module GraphQL
         @queries.each { |q| q.multiplex = self }
         @context = context
         @dataloader = @context[:dataloader] ||= @schema.dataloader_class.new
-        @tracers = schema.tracers + (context[:tracers] || [])
+        @tracers = schema.tracers + (context[:tracers] || EmptyObjects::EMPTY_ARRAY)
         @max_complexity = max_complexity
         @current_trace = context[:trace] ||= schema.new_trace(multiplex: self)
         @logger = nil

data/lib/graphql/execution/next.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+require "graphql/execution/prepare_object_step"
+require "graphql/execution/input_values"
+require "graphql/execution/field_resolve_step"
+require "graphql/execution/finalize"
+require "graphql/execution/load_argument_step"
+require "graphql/execution/resolve_type_step"
+require "graphql/execution/runner"
+require "graphql/execution/selections_step"
+module GraphQL
+  module Execution
+    module Finalizer
+      attr_accessor :path
+
+      def finalize_graphql_result(query, result_data, result_key)
+        raise RequiredImplementationMissingError, "#{self.class} must implement #finalize_graphql_result(query, result_data, result_key)\n\nresult_data: #{result_data}\nresult_key: #{result_key.inspect}"
+      end
+
+      def ast_node
+        ast_nodes&.first
+      end
+
+      def ast_node=(new_node)
+        @ast_nodes = [new_node]
+      end
+
+      attr_accessor :ast_nodes
+    end
+
+    module HaltExecution
+    end
+
+    module PostProcessor
+      def after_resolve(field_results)
+        raise RequiredImplementationMissingError, "#{self.class}#after_resolve should handle `field_results` and return a new value to use"
+      end
+    end
+
+    module Next
+      module SchemaExtension
+        def execute_next(query_str = nil, query: nil, subscription_topic: nil, context: nil, document: nil, operation_name: nil, variables: nil, warden: nil, root_value: nil, validate: true, visibility_profile: nil)
+          multiplex_context = if context
+            {
+              backtrace: context[:backtrace],
+              tracers: context[:tracers],
+              trace: context[:trace],
+              dataloader: context[:dataloader],
+              trace_mode: context[:trace_mode],
+            }
+          else
+            {}
+          end
+          query_opts = {
+            query: query || query_str,
+            subscription_topic: subscription_topic,
+            document: document,
+            context: context,
+            validate: validate,
+            variables: variables,
+            root_value: root_value,
+            operation_name: operation_name,
+            visibility_profile: visibility_profile,
+            warden: warden,
+          }
+          m_results = multiplex_next([query_opts], context: multiplex_context, max_complexity: nil)
+          m_results[0]
+        end
+
+        def multiplex_next(query_options, context: {}, max_complexity: self.max_complexity)
+          Next.run_all(self, query_options, context: context, max_complexity: max_complexity)
+        end
+      end
+
+      def self.use(schema, as_default: false)
+        schema.extend(SchemaExtension)
+        schema.default_execution_next(as_default)
+      end
+
+      def self.run_all(schema, query_options, context: {}, max_complexity: schema.max_complexity)
+        queries = query_options.map do |opts|
+          query = case opts
+          when Hash
+            schema.query_class.new(schema, nil, **opts)
+          when GraphQL::Query, GraphQL::Query::Partial
+            opts
+          else
+            raise "Expected Hash or GraphQL::Query, not #{opts.class} (#{opts.inspect})"
+          end
+          query.context[:__graphql_execute_next] = true
+          query
+        end
+        multiplex = Execution::Multiplex.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
+        runner = Runner.new(multiplex)
+        runner.execute
+      end
+    end
+  end
+end