graphql 2.5.11 → 2.5.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c2ef756861a779063236ee9f8745d30ae3494138674239c8f638556d7f5105e
-  data.tar.gz: 23592e61f76acb0be2a4c60d953a829e8f1d46534633513ac44797a5d3386d2a
+  metadata.gz: 3a94d75c592000805bf9fd18507343c0b3428f1cf1d9a1828edc921828fd2735
+  data.tar.gz: 2984583eb702965d43e45f58f1ac29b6a782b8ecf02b4ee1953b5c5bbb6ec872
 SHA512:
-  metadata.gz: 5c8db1d976343d569aa1fec1cee02de2c72947e0937fcd9917f8f6e078204efd373d244954e9e03b8dc7fd20066dcf7533bf4b52c706dba0f5640b60ae0465f0
-  data.tar.gz: 38422c543b159cc7243ac4dcc9139ed95b2583cab7942c60e4c557b89d6a4ffaa8fb1df94286fa3fbe4b918f5c116364d5fbe5c2afa611ba9d46d7ac56c18e61
+  metadata.gz: 743bd603f22bb38bdff984c75b37eea32d460aeafd50617fc52dc9c4b93fe1d3265df196b728432a7b2d6494a6ba20c47b658ee84b387377037ea173844c654b
+  data.tar.gz: 12354210f6208443a5ec0dc931606440de29bfe0bdb7c6468e7faf9bc013a67671eab62fcc3bd88405d1ffb840a5c0e04be337d9a6707d511a2046d315722f63

data/lib/generators/graphql/detailed_trace_generator.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+require 'rails/generators/active_record'
+
+module Graphql
+  module Generators
+    class DetailedTraceGenerator < ::Rails::Generators::Base
+      include ::Rails::Generators::Migration
+      desc "Install GraphQL::Tracing::DetailedTrace for your schema"
+      source_root File.expand_path('../templates', __FILE__)
+
+      class_option :redis,
+        type: :boolean,
+        default: false,
+        desc: "Use Redis for persistence instead of ActiveRecord"
+
+      def self.next_migration_number(dirname)
+        ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      def install_detailed_traces
+
+        schema_glob = File.expand_path("app/graphql/*_schema.rb", destination_root)
+        schema_file = Dir.glob(schema_glob).first
+        if !schema_file
+          raise ArgumentError, "Failed to find schema definition file (checked: #{schema_glob.inspect})"
+        end
+        schema_file_match = /( *)class ([A-Za-z:]+) < GraphQL::Schema/.match(File.read(schema_file))
+        schema_name = schema_file_match[2]
+        indent = schema_file_match[1] + "  "
+
+        if !options.redis?
+          migration_template 'create_graphql_detailed_traces.erb', 'db/migrate/create_graphql_detailed_traces.rb'
+        end
+
+        log :add_detailed_traces_plugin
+        sentinel = /< GraphQL::Schema\s*\n/m
+        code = <<-RUBY
+#{indent}use GraphQL::Tracing::DetailedTrace#{options.redis? ? ", redis: raise(\"TODO: pass a connection to a persistent redis database\")" : ""}, limit: 50
+
+#{indent}# When this returns true, DetailedTrace will trace the query
+#{indent}# Could use `query.context`, `query.selected_operation_name`, `query.query_string` here
+#{indent}# Could call out to Flipper, etc
+#{indent}def self.detailed_trace?(query)
+#{indent}  rand <= 0.000_1 # one in ten thousand
+#{indent}end
+
+        RUBY
+
+        in_root do
+          inject_into_file schema_file, code, after: sentinel, force: false
+        end
+
+        routes_source = File.read(File.expand_path("config/routes.rb", destination_root))
+        already_has_dashboard = routes_source.include?("GraphQL::Dashboard") ||
+          routes_source.include?("Schema.dashboard") ||
+          routes_source.include?("GraphQL::Pro::Routes::Lazy")
+
+        if (!already_has_dashboard || behavior == :revoke)
+          log :route, "GraphQL::Dashboard"
+          shell.mute do
+            route <<~RUBY
+            # TODO: add authorization to this route and expose it in production
+            # See https://graphql-ruby.org/pro/dashboard.html#authorizing-the-dashboard
+            if Rails.env.development?
+              mount GraphQL::Dashboard, at: "/graphql/dashboard", schema: #{schema_name.inspect}
+            end
+
+            RUBY
+          end
+
+          gem("google-protobuf")
+
+        end
+      end
+    end
+  end
+end

data/lib/generators/graphql/templates/create_graphql_detailed_traces.erb

@@ -0,0 +1,10 @@
+class CreateGraphqlDetailedTraces < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :graphql_detailed_traces, force: true do |t|
+      t.bigint :begin_ms, null: false
+      t.float :duration_ms, null: false
+      t.binary :trace_data, null: false
+      t.string :operation_name, null: false
+    end
+  end
+end

data/lib/graphql/dashboard/views/graphql/dashboard/operation_store/clients/_form.html.erb

@@ -20,4 +20,5 @@
     <div class="col-auto">
       <%= link_to "Back", graphql_dashboard.operation_store_clients_path, class: "btn btn-outline-secondary" %>
     </div>
+  </div>
 <% end %>

data/lib/graphql/dashboard/views/graphql/dashboard/operation_store/clients/edit.html.erb

@@ -3,10 +3,10 @@
   <div class="col">
     <h1>Edit <%= @client.name %></h1>
   </div>
-<div>
+</div>
 <%= render partial: "graphql/dashboard/operation_store/clients/form" %>
 
-<hr class="mt-5"/>
+<hr class="mt-5">
 <div class="row mt-5">
   <div class="col">
     <div class="alert alert-danger">

data/lib/graphql/dashboard/views/graphql/dashboard/operation_store/clients/index.html.erb

@@ -33,7 +33,7 @@
           <td><%= link_to(client.name, graphql_dashboard.edit_operation_store_client_path(name: client.name)) %></td>
           <td>
             <%= link_to(graphql_dashboard.operation_store_client_operations_path(client_name: client.name)) do %>
-              <%= client.operations_count %><% if client.archived_operations_count > 0 %> <span class="muted">(<%=client.archived_operations_count%> archived)</span><% end %>
+              <%= client.operations_count %><% if client.archived_operations_count > 0 %> <span class="muted">(<%= client.archived_operations_count %> archived)</span><% end %>
             <% end %>
           </td>
           <td><%= client.created_at %></td>

data/lib/graphql/dashboard/views/graphql/dashboard/operation_store/clients/new.html.erb

@@ -3,5 +3,5 @@
   <div class="col">
     <h1>New Client</h1>
   </div>
-<div>
+</div>
 <%= render partial: "graphql/dashboard/operation_store/clients/form" %>

data/lib/graphql/dashboard/views/graphql/dashboard/operation_store/index_entries/index.html.erb

@@ -10,7 +10,7 @@
     <form method="GET" action="<%= graphql_dashboard.operation_store_index_entries_path %>" style="margin-left: auto; margin-top:-5px;">
       <div class="input-group">
         <%= text_field_tag "q", @search_term, class: "form-control", placeholder: "Find types, fields, arguments, or enum values" %>
-        <input type="submit" value="Search" class="btn btn-outline-primary btn-sm"/>
+        <input type="submit" value="Search" class="btn btn-outline-primary btn-sm">
       </div>
     </form>
   </div>

data/lib/graphql/dashboard/views/graphql/dashboard/operation_store/operations/show.html.erb

@@ -2,7 +2,7 @@
 <% if @operation.nil? %>
   <div class="row">
     <div class="col">
-      <p>No stored operation found for <code><%= params[:digest] %></code>
+      <p>No stored operation found for <code><%= params[:digest] %></code></p>
     </div>
   </div>
 <% else %>

data/lib/graphql/dashboard/views/graphql/dashboard/subscriptions/topics/show.html.erb

@@ -9,7 +9,7 @@
   <div class="col">
     <p>Last triggered: <%= @topic_last_triggered_at || "none" %></p>
     <p><%= pluralize(@subscriptions_count, "Subscription") %></p>
-  <div>
+  </div>
 </div>
 
 <div class="row">

data/lib/graphql/dashboard/views/layouts/graphql/dashboard/application.html.erb

@@ -1,15 +1,15 @@
 <!doctype html>
 <html lang="en" class="h-100" >
   <head>
-    <link rel="icon" type="image/png" href="<%= graphql_dashboard.static_path("icon.png") %>" />
+    <link rel="icon" type="image/png" href="<%= graphql_dashboard.static_path("icon.png") %>">
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <title>GraphQL Dashboard <%= content_for?(:title) ? " · #{content_for(:title)}" : "" %> </title>
-    <%= stylesheet_link_tag graphql_dashboard.static_path("bootstrap-5.3.3.min.css") %>
-    <%= stylesheet_link_tag graphql_dashboard.static_path("charts.min.css") %>
-    <%= stylesheet_link_tag graphql_dashboard.static_path("dashboard.css") %>
-    <%= javascript_include_tag graphql_dashboard.static_path("bootstrap-5.3.3.min.js") %>
-    <%= javascript_include_tag graphql_dashboard.static_path("dashboard.js") %>
+    <link rel="stylesheet" href="<%= graphql_dashboard.static_path("bootstrap-5.3.3.min.css") %>" media="screen" />
+    <link rel="stylesheet" href="<%= graphql_dashboard.static_path("charts.min.css") %>" media="screen" />
+    <link rel="stylesheet" href="<%= graphql_dashboard.static_path("dashboard.css") %>" media="screen" />
+    <script src="<%= graphql_dashboard.static_path("bootstrap-5.3.3.min.js") %>"></script>
+    <script src="<%= graphql_dashboard.static_path("dashboard.js") %>"></script>
     <%= csrf_meta_tags %>
   </head>
   <body class="h-100 d-flex flex-column">
@@ -20,7 +20,7 @@
             <nav class="navbar navbar-expand-lg bg-body-tertiary">
               <div class="container-fluid">
                 <%= link_to graphql_dashboard.root_path, class: "navbar-brand" do %>
-                  <img id="header-icon" src="<%= graphql_dashboard.static_path("header-icon.png") %>" alt="GraphQL-Ruby" />
+                  <img id="header-icon" src="<%= graphql_dashboard.static_path("header-icon.png") %>" alt="GraphQL-Ruby">
                 <% end %>
                 <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
                   <span class="navbar-toggler-icon"></span>

data/lib/graphql/dashboard.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require 'rails/engine'
+require 'action_controller'
 module Graphql
   # `GraphQL::Dashboard` is a `Rails::Engine`-based dashboard for viewing metadata about your GraphQL schema.
   #
@@ -34,7 +35,7 @@ module Graphql
   class Dashboard < Rails::Engine
     engine_name "graphql_dashboard"
     isolate_namespace(Graphql::Dashboard)
-    routes.draw do
+    routes do
       root "landings#show"
       resources :statics, only: :show, constraints: { id: /[0-9A-Za-z\-.]+/ }
 
@@ -76,6 +77,8 @@ module Graphql
         resources :subscriptions, only: [:show], constraints: { id: /[a-zA-Z0-9\-]+/ }
         post "/subscriptions/clear_all", to: "subscriptions#clear_all", as: :clear_all
       end
+
+      ApplicationController.include(Dashboard.routes.url_helpers)
     end
 
     class ApplicationController < ActionController::Base
@@ -117,7 +120,7 @@ module Graphql
     end
 
     class StaticsController < ApplicationController
-      skip_after_action :verify_same_origin_request
+      skip_forgery_protection
       # Use an explicit list of files to avoid any chance of reading other files from disk
       STATICS = {}
 

data/lib/graphql/dataloader/async_dataloader.rb

@@ -14,7 +14,7 @@ module GraphQL
         nil
       end
 
-      def run
+      def run(trace_query_lazy: nil)
         trace = Fiber[:__graphql_current_multiplex]&.current_trace
         jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
         job_fibers = []
@@ -29,16 +29,7 @@ module GraphQL
             first_pass = false
             fiber_vars = get_fiber_variables
 
-            while (f = (job_fibers.shift || (((job_fibers.size + next_job_fibers.size + source_tasks.size) < jobs_fiber_limit) && spawn_job_fiber(trace))))
-              if f.alive?
-                finished = run_fiber(f)
-                if !finished
-                  next_job_fibers << f
-                end
-              end
-            end
-            job_fibers.concat(next_job_fibers)
-            next_job_fibers.clear
+            run_pending_steps(job_fibers, next_job_fibers, source_tasks, jobs_fiber_limit, trace)
 
             Sync do |root_task|
               set_fiber_variables(fiber_vars)
@@ -54,6 +45,13 @@ module GraphQL
                 next_source_tasks.clear
               end
             end
+
+            if !@lazies_at_depth.empty?
+              with_trace_query_lazy(trace_query_lazy) do
+                run_next_pending_lazies(job_fibers, trace)
+                run_pending_steps(job_fibers, next_job_fibers, source_tasks, jobs_fiber_limit, trace)
+              end
+            end
           end
           trace&.end_dataloader(self)
         end
@@ -69,6 +67,19 @@ module GraphQL
 
       private
 
+      def run_pending_steps(job_fibers, next_job_fibers, source_tasks, jobs_fiber_limit, trace)
+        while (f = (job_fibers.shift || (((job_fibers.size + next_job_fibers.size + source_tasks.size) < jobs_fiber_limit) && spawn_job_fiber(trace))))
+          if f.alive?
+            finished = run_fiber(f)
+            if !finished
+              next_job_fibers << f
+            end
+          end
+        end
+        job_fibers.concat(next_job_fibers)
+        next_job_fibers.clear
+      end
+
       def spawn_source_task(parent_task, condition, trace)
         pending_sources = nil
         @source_cache.each_value do |source_by_batch_params|

data/lib/graphql/dataloader/null_dataloader.rb

@@ -2,24 +2,58 @@
 
 module GraphQL
   class Dataloader
-    # The default implementation of dataloading -- all no-ops.
+    # GraphQL-Ruby uses this when Dataloader isn't enabled.
     #
-    # The Dataloader interface isn't public, but it enables
-    # simple internal code while adding the option to add Dataloader.
+    # It runs execution code inline and gathers lazy objects (eg. Promises)
+    # and resolves them during {#run}.
     class NullDataloader < Dataloader
-      # These are all no-ops because code was
-      # executed synchronously.
+      def initialize(*)
+        @lazies_at_depth = Hash.new { |h,k| h[k] = [] }
+      end
+
+      def freeze
+        @lazies_at_depth.default_proc = nil
+        @lazies_at_depth.freeze
+        super
+      end
+
+      def run(trace_query_lazy: nil)
+        with_trace_query_lazy(trace_query_lazy) do
+          while !@lazies_at_depth.empty?
+            smallest_depth = nil
+            @lazies_at_depth.each_key do |depth_key|
+              smallest_depth ||= depth_key
+              if depth_key < smallest_depth
+                smallest_depth = depth_key
+              end
+            end
+
+            if smallest_depth
+              lazies = @lazies_at_depth.delete(smallest_depth)
+              lazies.each(&:value) # resolve these Lazy instances
+            end
+          end
+        end
+      end
+
+      def run_isolated
+        new_dl = self.class.new
+        res = nil
+        new_dl.append_job {
+          res = yield
+        }
+        new_dl.run
+        res
+      end
 
-      def initialize(*); end
-      def run; end
-      def run_isolated; yield; end
       def clear_cache; end
+
       def yield(_source)
         raise GraphQL::Error, "GraphQL::Dataloader is not running -- add `use GraphQL::Dataloader` to your schema to use Dataloader sources."
       end
 
-      def append_job
-        yield
+      def append_job(callable = nil)
+        callable ? callable.call : yield
         nil
       end
 

data/lib/graphql/dataloader.rb

@@ -64,6 +64,7 @@ module GraphQL
         @nonblocking = nonblocking
       end
       @fiber_limit = fiber_limit
+      @lazies_at_depth = Hash.new { |h, k| h[k] = [] }
     end
 
     # @return [Integer, nil]
@@ -140,10 +141,10 @@ module GraphQL
     end
 
     # @api private Nothing to see here
-    def append_job(&job)
+    def append_job(callable = nil, &job)
       # Given a block, queue it up to be worked through when `#run` is called.
-      # (If the dataloader is already running, than a Fiber will pick this up later.)
-      @pending_jobs.push(job)
+      # (If the dataloader is already running, then a Fiber will pick this up later.)
+      @pending_jobs.push(callable || job)
       nil
     end
 
@@ -160,6 +161,10 @@ module GraphQL
     def run_isolated
       prev_queue = @pending_jobs
       prev_pending_keys = {}
+      prev_lazies_at_depth = @lazies_at_depth
+      @lazies_at_depth = @lazies_at_depth.dup.clear
+      # Clear pending loads but keep already-cached records
+      # in case they are useful to the given block.
       @source_cache.each do |source_class, batched_sources|
         batched_sources.each do |batch_args, batched_source_instance|
           if batched_source_instance.pending?
@@ -179,6 +184,7 @@ module GraphQL
       res
     ensure
       @pending_jobs = prev_queue
+      @lazies_at_depth = prev_lazies_at_depth
       prev_pending_keys.each do |source_instance, pending|
         pending.each do |key, value|
           if !source_instance.results.key?(key)
@@ -188,7 +194,8 @@ module GraphQL
       end
     end
 
-    def run
+    # @param trace_query_lazy [nil, Execution::Multiplex]
+    def run(trace_query_lazy: nil)
       trace = Fiber[:__graphql_current_multiplex]&.current_trace
       jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
       job_fibers = []
@@ -201,26 +208,13 @@ module GraphQL
         while first_pass || !job_fibers.empty?
           first_pass = false
 
-          while (f = (job_fibers.shift || (((next_job_fibers.size + job_fibers.size) < jobs_fiber_limit) && spawn_job_fiber(trace))))
-            if f.alive?
-              finished = run_fiber(f)
-              if !finished
-                next_job_fibers << f
-              end
-            end
-          end
-          join_queues(job_fibers, next_job_fibers)
-
-          while (!source_fibers.empty? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) })
-            while (f = source_fibers.shift || (((job_fibers.size + source_fibers.size + next_source_fibers.size + next_job_fibers.size) < total_fiber_limit) && spawn_source_fiber(trace)))
-              if f.alive?
-                finished = run_fiber(f)
-                if !finished
-                  next_source_fibers << f
-                end
-              end
+          run_pending_steps(trace, job_fibers, next_job_fibers, jobs_fiber_limit, source_fibers, next_source_fibers, total_fiber_limit)
+
+          if !@lazies_at_depth.empty?
+            with_trace_query_lazy(trace_query_lazy) do
+              run_next_pending_lazies(job_fibers, trace)
+              run_pending_steps(trace, job_fibers, next_job_fibers, jobs_fiber_limit, source_fibers, next_source_fibers, total_fiber_limit)
             end
-            join_queues(source_fibers, next_source_fibers)
           end
         end
 
@@ -248,6 +242,11 @@ module GraphQL
       f.resume
     end
 
+    # @api private
+    def lazy_at_depth(depth, lazy)
+      @lazies_at_depth[depth] << lazy
+    end
+
     def spawn_fiber
       fiber_vars = get_fiber_variables
       Fiber.new(blocking: !@nonblocking) {
@@ -275,6 +274,59 @@ module GraphQL
 
     private
 
+    def run_next_pending_lazies(job_fibers, trace)
+      smallest_depth = nil
+      @lazies_at_depth.each_key do |depth_key|
+        smallest_depth ||= depth_key
+        if depth_key < smallest_depth
+          smallest_depth = depth_key
+        end
+      end
+
+      if smallest_depth
+        lazies = @lazies_at_depth.delete(smallest_depth)
+        if !lazies.empty?
+          lazies.each_with_index do |l, idx|
+            append_job { l.value }
+          end
+          job_fibers.unshift(spawn_job_fiber(trace))
+        end
+      end
+    end
+
+    def run_pending_steps(trace, job_fibers, next_job_fibers, jobs_fiber_limit, source_fibers, next_source_fibers, total_fiber_limit)
+      while (f = (job_fibers.shift || (((next_job_fibers.size + job_fibers.size) < jobs_fiber_limit) && spawn_job_fiber(trace))))
+        if f.alive?
+          finished = run_fiber(f)
+          if !finished
+            next_job_fibers << f
+          end
+        end
+      end
+      join_queues(job_fibers, next_job_fibers)
+
+      while (!source_fibers.empty? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) })
+        while (f = source_fibers.shift || (((job_fibers.size + source_fibers.size + next_source_fibers.size + next_job_fibers.size) < total_fiber_limit) && spawn_source_fiber(trace)))
+          if f.alive?
+            finished = run_fiber(f)
+            if !finished
+              next_source_fibers << f
+            end
+          end
+        end
+        join_queues(source_fibers, next_source_fibers)
+      end
+    end
+
+    def with_trace_query_lazy(multiplex_or_nil, &block)
+      if (multiplex = multiplex_or_nil)
+        query = multiplex.queries.length == 1 ? multiplex.queries[0] : nil
+        multiplex.current_trace.execute_query_lazy(query: query, multiplex: multiplex, &block)
+      else
+        yield
+      end
+    end
+
     def calculate_fiber_limit
       total_fiber_limit = @fiber_limit || Float::INFINITY
       if total_fiber_limit < 4

data/lib/graphql/date_encoding_error.rb

@@ -10,7 +10,7 @@ module GraphQL
 
     def initialize(value)
       @date_value = value
-      super("Date cannot be parsed: #{value}. \nDate must be be able to be parsed as a Ruby Date object.")
+      super("Date cannot be parsed: #{value}. \nDate must be able to be parsed as a Ruby Date object.")
     end
   end
 end

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

@@ -6,12 +6,17 @@ module GraphQL
       module Resolve
         # Continue field results in `results` until there's nothing else to continue.
         # @return [void]
+        # @deprecated Call `dataloader.run` instead
         def self.resolve_all(results, dataloader)
+          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{caller(1, 5).map { |l| "\n    #{l}"}.join}"
           dataloader.append_job { resolve(results, dataloader) }
           nil
         end
 
+        # @deprecated Call `dataloader.run` instead
         def self.resolve_each_depth(lazies_at_depth, dataloader)
+          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{caller(1, 5).map { |l| "\n    #{l}"}.join}"
+
           smallest_depth = nil
           lazies_at_depth.each_key do |depth_key|
             smallest_depth ||= depth_key
@@ -34,20 +39,9 @@ module GraphQL
           nil
         end
 
-        # After getting `results` back from an interpreter evaluation,
-        # continue it until you get a response-ready Ruby value.
-        #
-        # `results` is one level of _depth_ of a query or multiplex.
-        #
-        # Resolve all lazy values in that depth before moving on
-        # to the next level.
-        #
-        # It's assumed that the lazies will
-        # return {Lazy} instances if there's more work to be done,
-        # or return {Hash}/{Array} if the query should be continued.
-        #
-        # @return [void]
+        # @deprecated Call `dataloader.run` instead
         def self.resolve(results, dataloader)
+          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{caller(1, 5).map { |l| "\n    #{l}"}.join}"
           # There might be pending jobs here that _will_ write lazies
           # into the result hash. We should run them out, so we
           # can be sure that all lazies will be present in the result hashes.

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

@@ -42,6 +42,14 @@ module GraphQL
             end
           end
 
+          def depth
+            @depth ||= if @graphql_parent
+              @graphql_parent.depth + 1
+            else
+              1
+            end
+          end
+
           attr_accessor :graphql_dead
           attr_reader :graphql_parent, :graphql_result_name, :graphql_is_non_null_in_parent,
             :graphql_application_value, :graphql_result_type, :graphql_selections, :graphql_is_eager, :ast_node, :graphql_arguments, :graphql_field
@@ -157,6 +165,11 @@ module GraphQL
               end
             end
           end
+
+          # hook for breadth-first implementations to signal when collecting results.
+          def collect_result(result_name, result_value)
+            false
+          end
         end
 
         class GraphQLResultArray