graphql 2.0.20 → 2.0.22

data/lib/graphql/schema/member/has_fields.rb

@@ -14,42 +14,6 @@ module GraphQL
           field_defn
         end
 
-        # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
-        def fields(context = GraphQL::Query::NullContext)
-          warden = Warden.from_context(context)
-          is_object = self.respond_to?(:kind) && self.kind.object?
-          # Local overrides take precedence over inherited fields
-          visible_fields = {}
-          for ancestor in ancestors
-            if ancestor.respond_to?(:own_fields) &&
-                (is_object ? visible_interface_implementation?(ancestor, context, warden) : true)
-
-              ancestor.own_fields.each do |field_name, fields_entry|
-                # Choose the most local definition that passes `.visible?` --
-                # stop checking for fields by name once one has been found.
-                if !visible_fields.key?(field_name) && (f = Warden.visible_entry?(:visible_field?, fields_entry, context, warden))
-                  visible_fields[field_name] = f
-                end
-              end
-            end
-          end
-          visible_fields
-        end
-
-        def get_field(field_name, context = GraphQL::Query::NullContext)
-          warden = Warden.from_context(context)
-          is_object = self.respond_to?(:kind) && self.kind.object?
-          for ancestor in ancestors
-            if ancestor.respond_to?(:own_fields) &&
-                (is_object ? visible_interface_implementation?(ancestor, context, warden) : true) &&
-                (f_entry = ancestor.own_fields[field_name]) &&
-                (f = Warden.visible_entry?(:visible_field?, f_entry, context, warden))
-              return f
-            end
-          end
-          nil
-        end
-
         # A list of Ruby keywords.
         #
         # @api private
@@ -132,6 +96,86 @@ module GraphQL
           all_fields
         end
 
+        module InterfaceMethods
+          def get_field(field_name, context = GraphQL::Query::NullContext)
+            warden = Warden.from_context(context)
+            for ancestor in ancestors
+              if ancestor.respond_to?(:own_fields) &&
+                  (f_entry = ancestor.own_fields[field_name]) &&
+                  (f = Warden.visible_entry?(:visible_field?, f_entry, context, warden))
+                return f
+              end
+            end
+            nil
+          end
+
+          # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
+          def fields(context = GraphQL::Query::NullContext)
+            warden = Warden.from_context(context)
+            # Local overrides take precedence over inherited fields
+            visible_fields = {}
+            for ancestor in ancestors
+              if ancestor.respond_to?(:own_fields)
+                ancestor.own_fields.each do |field_name, fields_entry|
+                  # Choose the most local definition that passes `.visible?` --
+                  # stop checking for fields by name once one has been found.
+                  if !visible_fields.key?(field_name) && (f = Warden.visible_entry?(:visible_field?, fields_entry, context, warden))
+                    visible_fields[field_name] = f
+                  end
+                end
+              end
+            end
+            visible_fields
+          end
+        end
+
+        module ObjectMethods
+          def get_field(field_name, context = GraphQL::Query::NullContext)
+            # Objects need to check that the interface implementation is visible, too
+            warden = Warden.from_context(context)
+            for ancestor in ancestors
+              if ancestor.respond_to?(:own_fields) &&
+                  visible_interface_implementation?(ancestor, context, warden) &&
+                  (f_entry = ancestor.own_fields[field_name]) &&
+                  (f = Warden.visible_entry?(:visible_field?, f_entry, context, warden))
+                return f
+              end
+            end
+            nil
+          end
+
+          # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
+          def fields(context = GraphQL::Query::NullContext)
+            # Objects need to check that the interface implementation is visible, too
+            warden = Warden.from_context(context)
+            # Local overrides take precedence over inherited fields
+            visible_fields = {}
+            for ancestor in ancestors
+              if ancestor.respond_to?(:own_fields) && visible_interface_implementation?(ancestor, context, warden)
+                ancestor.own_fields.each do |field_name, fields_entry|
+                  # Choose the most local definition that passes `.visible?` --
+                  # stop checking for fields by name once one has been found.
+                  if !visible_fields.key?(field_name) && (f = Warden.visible_entry?(:visible_field?, fields_entry, context, warden))
+                    visible_fields[field_name] = f
+                  end
+                end
+              end
+            end
+            visible_fields
+          end
+        end
+
+        def self.included(child_class)
+          # Included in an interface definition methods module
+          child_class.include(InterfaceMethods)
+          super
+        end
+
+        def self.extended(child_class)
+          child_class.extend(ObjectMethods)
+          super
+        end
+
         private
 
         def inherited(subclass)

data/lib/graphql/schema/member/has_validators.rb

@@ -3,7 +3,7 @@ module GraphQL
   class Schema
     class Member
       module HasValidators
-        include Schema::FindInheritedValue::EmptyObjects
+        include GraphQL::EmptyObjects
 
         # Build {GraphQL::Schema::Validator}s based on the given configuration
         # and use them for this schema member
@@ -28,7 +28,7 @@ module GraphQL
           end
 
           module ClassValidators
-            include Schema::FindInheritedValue::EmptyObjects
+            include GraphQL::EmptyObjects
 
             def validators
               inherited_validators = superclass.validators

data/lib/graphql/schema/object.rb

@@ -68,7 +68,7 @@ module GraphQL
             maybe_lazy_auth_val
           end
 
-          context.schema.after_lazy(auth_val) do |is_authorized|
+          context.query.after_lazy(auth_val) do |is_authorized|
             if is_authorized
               self.new(object, context)
             else

data/lib/graphql/schema/printer.rb

@@ -57,12 +57,14 @@ module GraphQL
         query_root = Class.new(GraphQL::Schema::Object) do
           graphql_name "Root"
           field :throwaway_field, String
+          def self.visible?(ctx)
+            false
+          end
         end
         schema = Class.new(GraphQL::Schema) { query(query_root) }
 
         introspection_schema_ast = GraphQL::Language::DocumentFromSchemaDefinition.new(
           schema,
-          except: ->(member, _) { member.graphql_name == "Root" },
           include_introspection_types: true,
           include_built_in_directives: true,
         ).document

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -60,7 +60,7 @@ module GraphQL
           super()
         end
 
-        context.schema.after_lazy(return_value) do |return_hash|
+        context.query.after_lazy(return_value) do |return_hash|
           # It might be an error
           if return_hash.is_a?(Hash)
             return_hash[:client_mutation_id] = client_mutation_id

data/lib/graphql/schema/resolver.rb

@@ -70,7 +70,7 @@ module GraphQL
         else
           ready?
         end
-        context.schema.after_lazy(ready_val) do |is_ready, ready_early_return|
+        context.query.after_lazy(ready_val) do |is_ready, ready_early_return|
           if ready_early_return
             if is_ready != false
               raise "Unexpected result from #ready? (expected `true`, `false` or `[false, {...}]`): [#{is_ready.inspect}, #{ready_early_return.inspect}]"
@@ -81,7 +81,7 @@ module GraphQL
             # Then call each prepare hook, which may return a different value
             # for that argument, or may return a lazy object
             load_arguments_val = load_arguments(args)
-            context.schema.after_lazy(load_arguments_val) do |loaded_args|
+            context.query.after_lazy(load_arguments_val) do |loaded_args|
               @prepared_arguments = loaded_args
               Schema::Validator.validate!(self.class.validators, object, context, loaded_args, as: @field)
               # Then call `authorized?`, which may raise or may return a lazy object
@@ -90,7 +90,7 @@ module GraphQL
               else
                 authorized?
               end
-              context.schema.after_lazy(authorized_val) do |(authorized_result, early_return)|
+              context.query.after_lazy(authorized_val) do |(authorized_result, early_return)|
                 # If the `authorized?` returned two values, `false, early_return`,
                 # then use the early return value instead of continuing
                 if early_return
@@ -185,7 +185,7 @@ module GraphQL
           if arg_defn
             prepped_value = prepared_args[key] = arg_defn.load_and_authorize_value(self, value, context)
             if context.schema.lazy?(prepped_value)
-              prepare_lazies << context.schema.after_lazy(prepped_value) do |finished_prepped_value|
+              prepare_lazies << context.query.after_lazy(prepped_value) do |finished_prepped_value|
                 prepared_args[key] = finished_prepped_value
               end
             end
@@ -311,8 +311,8 @@ module GraphQL
         # (`nil` means "unlimited max page size".)
         # @param max_page_size [Integer, nil] Set a new value
         # @return [Integer, nil] The `max_page_size` assigned to fields that use this resolver
-        def max_page_size(new_max_page_size = :not_given)
-          if new_max_page_size != :not_given
+        def max_page_size(new_max_page_size = NOT_CONFIGURED)
+          if new_max_page_size != NOT_CONFIGURED
             @max_page_size = new_max_page_size
           elsif defined?(@max_page_size)
             @max_page_size
@@ -332,8 +332,8 @@ module GraphQL
         # (`nil` means "unlimited default page size".)
         # @param default_page_size [Integer, nil] Set a new value
         # @return [Integer, nil] The `default_page_size` assigned to fields that use this resolver
-        def default_page_size(new_default_page_size = :not_given)
-          if new_default_page_size != :not_given
+        def default_page_size(new_default_page_size = NOT_CONFIGURED)
+          if new_default_page_size != NOT_CONFIGURED
             @default_page_size = new_default_page_size
           elsif defined?(@default_page_size)
             @default_page_size

data/lib/graphql/schema/validator.rb

@@ -102,7 +102,7 @@ module GraphQL
 
       self.all_validators = {}
 
-      include Schema::FindInheritedValue::EmptyObjects
+      include GraphQL::EmptyObjects
 
       class ValidationFailedError < GraphQL::ExecutionError
         attr_reader :errors

data/lib/graphql/schema/warden.rb

@@ -38,7 +38,9 @@ module GraphQL
     # @api private
     class Warden
       def self.from_context(context)
-        (context.respond_to?(:warden) && context.warden) || PassThruWarden
+        context.warden # this might be a hash which won't respond to this
+      rescue
+        PassThruWarden
       end
 
       # @param visibility_method [Symbol] a Warden method to call for this entry
@@ -88,14 +90,20 @@ module GraphQL
       # @param filter [<#call(member)>] Objects are hidden when `.call(member, ctx)` returns true
       # @param context [GraphQL::Query::Context]
       # @param schema [GraphQL::Schema]
-      def initialize(filter, context:, schema:)
+      def initialize(filter = nil, context:, schema:)
         @schema = schema
         # Cache these to avoid repeated hits to the inheritance chain when one isn't present
         @query = @schema.query
         @mutation = @schema.mutation
         @subscription = @schema.subscription
         @context = context
-        @visibility_cache = read_through { |m| filter.call(m, context) }
+        @visibility_cache = if filter
+          read_through { |m| filter.call(m, context) }
+        else
+          read_through { |m| schema.visible?(m, context) }
+        end
+
+        @visibility_cache.compare_by_identity
         # Initialize all ivars to improve object shape consistency:
         @types = @visible_types = @reachable_types = @visible_parent_fields =
           @visible_possible_types = @visible_fields = @visible_arguments = @visible_enum_arrays =

data/lib/graphql/schema.rb

@@ -145,18 +145,41 @@ module GraphQL
 
       def trace_class(new_class = nil)
         if new_class
-          @trace_class = new_class
-        elsif !defined?(@trace_class)
-          parent_trace_class = if superclass.respond_to?(:trace_class)
-            superclass.trace_class
+          trace_mode(:default, new_class)
+          backtrace_class = Class.new(new_class)
+          backtrace_class.include(GraphQL::Backtrace::Trace)
+          trace_mode(:default_backtrace, backtrace_class)
+        end
+        trace_class_for(:default)
+      end
+
+      # @return [Class] Return the trace class to use for this mode, looking one up on the superclass if this Schema doesn't have one defined.
+      def trace_class_for(mode)
+        @trace_modes ||= {}
+        @trace_modes[mode] ||= begin
+          base_class = if superclass.respond_to?(:trace_class_for)
+            superclass.trace_class_for(mode)
+          elsif mode == :default_backtrace
+            GraphQL::Backtrace::DefaultBacktraceTrace
           else
             GraphQL::Tracing::Trace
           end
-          @trace_class = Class.new(parent_trace_class)
+          Class.new(base_class)
         end
-        @trace_class
       end
 
+      # Configure `trace_class` to be used whenever `context: { trace_mode: mode_name }` is requested.
+      # `:default` is used when no `trace_mode: ...` is requested.
+      # @param mode_name [Symbol]
+      # @param trace_class [Class] subclass of GraphQL::Tracing::Trace
+      # @return void
+      def trace_mode(mode_name, trace_class)
+        @trace_modes ||= {}
+        @trace_modes[mode_name] = trace_class
+        nil
+      end
+
+
       # Returns the JSON response of {Introspection::INTROSPECTION_QUERY}.
       # @see {#as_json}
       # @return [String]
@@ -226,6 +249,8 @@ module GraphQL
 
       def default_mask(new_mask = nil)
         if new_mask
+          line = caller(2, 10).find { |l| !l.include?("lib/graphql") }
+          GraphQL::Deprecation.warn("GraphQL::Filter and Schema.mask are deprecated and will be removed in v2.1.0. Implement `visible?` on your schema members instead (https://graphql-ruby.org/authorization/visibility.html).\n  #{line}")
           @own_default_mask = new_mask
         else
           @own_default_mask || find_inherited_value(:default_mask, Schema::NullMask)
@@ -936,10 +961,10 @@ module GraphQL
       end
 
       def tracer(new_tracer)
-        if defined?(@trace_class) && !(@trace_class < GraphQL::Tracing::LegacyTrace)
+        if defined?(@trace_modes) && !(trace_class_for(:default) < GraphQL::Tracing::LegacyTrace)
           raise ArgumentError, "Can't add tracer after configuring a `trace_class`, use GraphQL::Tracing::LegacyTrace to merge legacy tracers into a trace class instead."
-        elsif !defined?(@trace_class)
-          @trace_class = Class.new(GraphQL::Tracing::LegacyTrace)
+        else
+          trace_mode(:default, Class.new(GraphQL::Tracing::LegacyTrace))
         end
 
         own_tracers << new_tracer
@@ -965,10 +990,14 @@ module GraphQL
       end
 
       def new_trace(**options)
-        if defined?(@trace_options)
-          options = trace_options.merge(options)
+        options = trace_options.merge(options)
+        trace_mode = if (target = options[:query] || options[:multiplex]) && target.context[:backtrace]
+          :default_backtrace
+        else
+          :default
         end
-        trace_class.new(**options)
+        trace = trace_class_for(trace_mode).new(**options)
+        trace
       end
 
       def query_analyzer(new_analyzer)

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

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

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

@@ -9,7 +9,7 @@ module GraphQL
       # without ambiguity.
       #
       # Original Algorithm: https://github.com/graphql/graphql-js/blob/master/src/validation/rules/OverlappingFieldsCanBeMerged.js
-      NO_ARGS = {}.freeze
+      NO_ARGS = GraphQL::EmptyObjects::EMPTY_HASH
 
       Field = Struct.new(:node, :definition, :owner_type, :parents)
       FragmentSpread = Struct.new(:name, :parents)
@@ -323,7 +323,7 @@ module GraphQL
         end
       end
 
-      NO_SELECTIONS = [{}.freeze, [].freeze].freeze
+      NO_SELECTIONS = [GraphQL::EmptyObjects::EMPTY_HASH, GraphQL::EmptyObjects::EMPTY_ARRAY].freeze
 
       def fields_and_fragments_from_selection(node, owner_type:, parents:)
         if node.selections.empty?

data/lib/graphql/tracing/appsignal_trace.rb

@@ -55,6 +55,12 @@ module GraphQL
         end
       end
 
+      def platform_resolve_type(platform_key)
+        Appsignal.instrument(platform_key) do
+          yield
+        end
+      end
+
       def platform_field_key(field)
         "#{field.owner.graphql_name}.#{field.graphql_name}.graphql"
       end

data/lib/graphql/tracing/legacy_trace.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+module GraphQL
+  module Tracing
+    # This trace class calls legacy-style tracer with payload hashes.
+    # New-style `trace_with` modules significantly reduce the overhead of tracing,
+    # but that advantage is lost when legacy-style tracers are also used (since the payload hashes are still constructed).
+    class LegacyTrace < Trace
+      def lex(query_string:)
+        (@multiplex || @query).trace("lex", { query_string: query_string }) { super }
+      end
+
+      def parse(query_string:)
+        (@multiplex || @query).trace("parse", { query_string: query_string }) { super }
+      end
+
+      def validate(query:, validate:)
+        query.trace("validate", { validate: validate, query: query }) { super }
+      end
+
+      def analyze_multiplex(multiplex:)
+        multiplex.trace("analyze_multiplex", { multiplex: multiplex }) { super }
+      end
+
+      def analyze_query(query:)
+        query.trace("analyze_query", { query: query }) { super }
+      end
+
+      def execute_multiplex(multiplex:)
+        multiplex.trace("execute_multiplex", { multiplex: multiplex }) { super }
+      end
+
+      def execute_query(query:)
+        query.trace("execute_query", { query: query }) { super }
+      end
+
+      def execute_query_lazy(query:, multiplex:)
+        multiplex.trace("execute_query_lazy", { multiplex: multiplex, query: query }) { super }
+      end
+
+      def execute_field(field:, query:, ast_node:, arguments:, object:)
+        query.trace("execute_field", { field: field, query: query, ast_node: ast_node, arguments: arguments, object: object, owner: field.owner, path: query.context[:current_path] }) { super }
+      end
+
+      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
+        query.trace("execute_field_lazy", { field: field, query: query, ast_node: ast_node, arguments: arguments, object: object, owner: field.owner, path: query.context[:current_path] }) { super }
+      end
+
+      def authorized(query:, type:, object:)
+        query.trace("authorized", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def authorized_lazy(query:, type:, object:)
+        query.trace("authorized_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def resolve_type(query:, type:, object:)
+        query.trace("resolve_type", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def resolve_type_lazy(query:, type:, object:)
+        query.trace("resolve_type_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+    end
+  end
+end

data/lib/graphql/tracing/notifications_trace.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_trace"
+
 module GraphQL
   module Tracing
     # This implementation forwards events to a notification handler (i.e.
     # ActiveSupport::Notifications or Dry::Monitor::Notifications)
     # with a `graphql` suffix.
     module NotificationsTrace
-      include PlatformTrace
       # Initialize a new NotificationsTracing instance
       #
       # @param engine [#instrument(key, metadata, block)] The notifications engine to use
@@ -21,6 +22,7 @@ module GraphQL
         "validate" => "validate.graphql",
         "analyze_multiplex" => "analyze_multiplex.graphql",
         "analyze_query" => "analyze_query.graphql",
+        "execute_multiplex" => "execute_multiplex.graphql",
         "execute_query" => "execute_query.graphql",
         "execute_query_lazy" => "execute_query_lazy.graphql",
         "execute_field" => "execute_field.graphql",
@@ -36,6 +38,8 @@ module GraphQL
           end
         RUBY
       end
+
+      include PlatformTrace
     end
   end
 end

data/lib/graphql/tracing/platform_trace.rb

@@ -29,28 +29,30 @@ module GraphQL
           child_class.instance_method(:platform_execute_field).arity != 1
 
         [:execute_field, :execute_field_lazy].each do |field_trace_method|
-          child_class.module_eval <<-RUBY, __FILE__, __LINE__
-            def #{field_trace_method}(query:, field:, ast_node:, arguments:, object:)
-              return_type = field.type.unwrap
-              trace_field = if return_type.kind.scalar? || return_type.kind.enum?
-                (field.trace.nil? && @trace_scalars) || field.trace
-              else
-                true
-              end
-              platform_key = if trace_field
-                @platform_field_key_cache[field]
-              else
-                nil
-              end
-              if platform_key && trace_field
-                platform_#{field_trace_method}(platform_key#{pass_data_to_execute_field ? ", { query: query, field: field, ast_node: ast_node, arguments: arguments, object: object }" : ""}) do
+          if !child_class.method_defined?(field_trace_method)
+            child_class.module_eval <<-RUBY, __FILE__, __LINE__
+              def #{field_trace_method}(query:, field:, ast_node:, arguments:, object:)
+                return_type = field.type.unwrap
+                trace_field = if return_type.kind.scalar? || return_type.kind.enum?
+                  (field.trace.nil? && @trace_scalars) || field.trace
+                else
+                  true
+                end
+                platform_key = if trace_field
+                  @platform_field_key_cache[field]
+                else
+                  nil
+                end
+                if platform_key && trace_field
+                  platform_#{field_trace_method}(platform_key#{pass_data_to_execute_field ? ", { query: query, field: field, ast_node: ast_node, arguments: arguments, object: object }" : ""}) do
+                    super
+                  end
+                else
                   super
                 end
-              else
-                super
               end
-            end
-          RUBY
+            RUBY
+          end
         end
 
 

data/lib/graphql/tracing/prometheus_tracing/graphql_collector.rb

@@ -5,7 +5,7 @@ module GraphQL
     class PrometheusTracing < PlatformTracing
       class GraphQLCollector < ::PrometheusExporter::Server::TypeCollector
         def initialize
-          @graphql_gauge = PrometheusExporter::Metric::Summary.new(
+          @graphql_gauge = PrometheusExporter::Metric::Base.default_aggregation.new(
             'graphql_duration_seconds',
             'Time spent in GraphQL operations, in seconds'
           )

data/lib/graphql/tracing/trace.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+module GraphQL
+  module Tracing
+    # This is the base class for a `trace` instance whose methods are called during query execution.
+    # "Trace modes" are subclasses of this with custom tracing modules mixed in.
+    #
+    # A trace module may implement any of the methods on `Trace`, being sure to call `super`
+    # to continue any tracing hooks and call the actual runtime behavior. See {GraphQL::Backtrace::Trace} for example.
+    #
+    class Trace
+      # @param multiplex [GraphQL::Execution::Multiplex, nil]
+      # @param query [GraphQL::Query, nil]
+      def initialize(multiplex: nil, query: nil, **_options)
+        @multiplex = multiplex
+        @query = query
+      end
+
+      def lex(query_string:)
+        yield
+      end
+
+      def parse(query_string:)
+        yield
+      end
+
+      def validate(query:, validate:)
+        yield
+      end
+
+      def analyze_multiplex(multiplex:)
+        yield
+      end
+
+      def analyze_query(query:)
+        yield
+      end
+
+      def execute_multiplex(multiplex:)
+        yield
+      end
+
+      def execute_query(query:)
+        yield
+      end
+
+      def execute_query_lazy(query:, multiplex:)
+        yield
+      end
+
+      def execute_field(field:, query:, ast_node:, arguments:, object:)
+        yield
+      end
+
+      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
+        yield
+      end
+
+      def authorized(query:, type:, object:)
+        yield
+      end
+
+      def authorized_lazy(query:, type:, object:)
+        yield
+      end
+
+      def resolve_type(query:, type:, object:)
+        yield
+      end
+
+      def resolve_type_lazy(query:, type:, object:)
+        yield
+      end
+    end
+  end
+end