graphql 2.2.5 → 2.3.2

data/lib/graphql/schema/field.rb

@@ -471,6 +471,8 @@ module GraphQL
             if arguments[:last] && (max_possible_page_size.nil? || arguments[:last] > max_possible_page_size)
               max_possible_page_size = arguments[:last]
             end
+          elsif arguments.is_a?(GraphQL::UnauthorizedError)
+            raise arguments
           end
 
           if max_possible_page_size.nil?
@@ -483,41 +485,24 @@ module GraphQL
             metadata_complexity = 0
             lookahead = GraphQL::Execution::Lookahead.new(query: query, field: self, ast_nodes: nodes, owner_type: owner)
 
-            if (page_info_lookahead = lookahead.selection(:page_info)).selected?
-              metadata_complexity += 1 # pageInfo
-              metadata_complexity += page_info_lookahead.selections.size # subfields
-            end
-
-            if lookahead.selects?(:total) || lookahead.selects?(:total_count) || lookahead.selects?(:count)
-              metadata_complexity += 1
+            lookahead.selections.each do |next_lookahead|
+              # this includes `pageInfo`, `nodes` and `edges` and any custom fields
+              # TODO this doesn't support procs yet -- unlikely to need it.
+              metadata_complexity += next_lookahead.field.complexity
+              if next_lookahead.name != :nodes && next_lookahead.name != :edges
+                # subfields, eg, for pageInfo -- assumes no subselections
+                metadata_complexity += next_lookahead.selections.size
+              end
             end
 
-            nodes_edges_complexity = 0
-            nodes_edges_complexity += 1 if lookahead.selects?(:edges)
-            nodes_edges_complexity += 1 if lookahead.selects?(:nodes)
-
             # Possible bug: selections on `edges` and `nodes` are _both_ multiplied here. Should they be?
-            items_complexity = child_complexity - metadata_complexity - nodes_edges_complexity
-            # Add 1 for _this_ field
-            1 + (max_possible_page_size * items_complexity) + metadata_complexity + nodes_edges_complexity
+            items_complexity = child_complexity - metadata_complexity
+            subfields_complexity = (max_possible_page_size * items_complexity) + metadata_complexity
+            # Apply this field's own complexity
+            apply_own_complexity_to(subfields_complexity, query, nodes)
           end
         else
-          defined_complexity = complexity
-          case defined_complexity
-          when Proc
-            arguments = query.arguments_for(nodes.first, self)
-            if arguments.is_a?(GraphQL::ExecutionError)
-              return child_complexity
-            elsif arguments.respond_to?(:keyword_arguments)
-              arguments = arguments.keyword_arguments
-            end
-
-            defined_complexity.call(query.context, arguments, child_complexity)
-          when Numeric
-            defined_complexity + child_complexity
-          else
-            raise("Invalid complexity: #{defined_complexity.inspect} on #{path} (#{inspect})")
-          end
+          apply_own_complexity_to(child_complexity, query, nodes)
         end
       end
 
@@ -882,6 +867,24 @@ ERR
           yield(obj, args)
         end
       end
+
+      def apply_own_complexity_to(child_complexity, query, nodes)
+        case (own_complexity = complexity)
+        when Numeric
+          own_complexity + child_complexity
+        when Proc
+          arguments = query.arguments_for(nodes.first, self)
+          if arguments.is_a?(GraphQL::ExecutionError)
+            return child_complexity
+          elsif arguments.respond_to?(:keyword_arguments)
+            arguments = arguments.keyword_arguments
+          end
+
+          own_complexity.call(query.context, arguments, child_complexity)
+        else
+          raise ArgumentError, "Invalid complexity for #{self.path}: #{own_complexity.inspect}"
+        end
+      end
     end
   end
 end

data/lib/graphql/schema/input_object.rb

@@ -215,8 +215,7 @@ module GraphQL
             if resolved_arguments.is_a?(GraphQL::Error)
               raise resolved_arguments
             else
-              input_obj_instance = self.new(resolved_arguments, ruby_kwargs: resolved_arguments.keyword_arguments, context: ctx, defaults_used: nil)
-              input_obj_instance.prepare
+              self.new(resolved_arguments, ruby_kwargs: resolved_arguments.keyword_arguments, context: ctx, defaults_used: nil)
             end
           end
         end

data/lib/graphql/schema/interface.rb

@@ -69,7 +69,11 @@ module GraphQL
             end
           elsif child_class < GraphQL::Schema::Object
             # This is being included into an object type, make sure it's using `implements(...)`
-            backtrace_line = caller(0, 10).find { |line| line.include?("schema/member/has_interfaces.rb") && line.include?("in `implements'")}
+            backtrace_line = caller_locations(0, 10).find do |location|
+              location.base_label == "implements" &&
+                location.path.end_with?("schema/member/has_interfaces.rb")
+            end
+
             if !backtrace_line
               raise "Attach interfaces using `implements(#{self})`, not `include(#{self})`"
             end

data/lib/graphql/schema/loader.rb

@@ -32,7 +32,8 @@ module GraphQL
         end
 
         Class.new(GraphQL::Schema) do
-          orphan_types(types.values)
+          add_type_and_traverse(types.values, root: false)
+          orphan_types(types.values.select { |t| t.kind.object? })
           directives(directives)
           description(schema["description"])
 

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

@@ -50,7 +50,7 @@ module GraphQL
             if loads && arg_defn.type.list?
               class_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{method_owner}load_#{arg_defn.keyword}(values, context = nil)
-                argument = get_argument("#{arg_defn.graphql_name}")
+                argument = get_argument("#{arg_defn.graphql_name}", context || self.context)
                 (context || self.context).query.after_lazy(values) do |values2|
                   GraphQL::Execution::Lazy.all(values2.map { |value| load_application_object(argument, value, context || self.context) })
                 end
@@ -59,7 +59,7 @@ module GraphQL
             elsif loads
               class_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{method_owner}load_#{arg_defn.keyword}(value, context = nil)
-                argument = get_argument("#{arg_defn.graphql_name}")
+                argument = get_argument("#{arg_defn.graphql_name}", context || self.context)
                 load_application_object(argument, value, context || self.context)
               end
               RUBY

data/lib/graphql/schema/mutation.rb

@@ -62,6 +62,13 @@ module GraphQL
       extend GraphQL::Schema::Member::HasFields
       extend GraphQL::Schema::Resolver::HasPayloadType
 
+      # @api private
+      def call_resolve(_args_hash)
+        # Clear any cached values from `loads` or authorization:
+        dataloader.clear_cache
+        super
+      end
+
       class << self
         def visible?(context)
           true

data/lib/graphql/schema/resolver.rb

@@ -103,11 +103,7 @@ module GraphQL
                   end
                 elsif authorized_val
                   # Finally, all the hooks have passed, so resolve it
-                  if loaded_args.any?
-                    public_send(self.class.resolve_method, **loaded_args)
-                  else
-                    public_send(self.class.resolve_method)
-                  end
+                  call_resolve(loaded_args)
                 else
                   raise GraphQL::UnauthorizedFieldError.new(context: context, object: object, type: field.owner, field: field)
                 end
@@ -117,6 +113,15 @@ module GraphQL
         end
       end
 
+      # @api private {GraphQL::Schema::Mutation} uses this to clear the dataloader cache
+      def call_resolve(args_hash)
+        if args_hash.any?
+          public_send(self.class.resolve_method, **args_hash)
+        else
+          public_send(self.class.resolve_method)
+        end
+      end
+
       # Do the work. Everything happens here.
       # @return [Object] An object corresponding to the return type
       def resolve(**args)
@@ -166,11 +171,15 @@ module GraphQL
         args.each_value do |argument|
           arg_keyword = argument.keyword
           if inputs.key?(arg_keyword) && !(arg_value = inputs[arg_keyword]).nil? && (arg_value != argument.default_value)
-            arg_auth, err = argument.authorized?(self, arg_value, context)
-            if !arg_auth
-              return arg_auth, err
-            else
-              true
+            auth_result = argument.authorized?(self, arg_value, context)
+            if auth_result.is_a?(Array)
+              # only return this second value if the application returned a second value
+              arg_auth, err = auth_result
+              if !arg_auth
+                return arg_auth, err
+              end
+            elsif auth_result == false
+              return auth_result
             end
           else
             true

data/lib/graphql/schema/unique_within_type.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-require 'graphql/schema/base_64_bp'
+require "base64"
 
 module GraphQL
   class Schema

data/lib/graphql/schema.rb

@@ -63,10 +63,6 @@ module GraphQL
   # Schemas can restrict large incoming queries with `max_depth` and `max_complexity` configurations.
   # (These configurations can be overridden by specific calls to {Schema#execute})
   #
-  # Schemas can specify how queries should be executed against them.
-  # `query_execution_strategy`, `mutation_execution_strategy` and `subscription_execution_strategy`
-  # each apply to corresponding root types.
-  #
   # @example defining a schema
   #   class MySchema < GraphQL::Schema
   #     query QueryType
@@ -162,18 +158,29 @@ module GraphQL
 
       def trace_class(new_class = nil)
         if new_class
+          # If any modules were already added for `:default`,
+          # re-apply them here
+          mods = trace_modules_for(:default)
+          mods.each { |mod| new_class.include(mod) }
           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)
+        trace_class_for(:default, build: true)
       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, build: true)
-        own_trace_modes[mode] ||
-          (superclass.respond_to?(:trace_class_for) ? superclass.trace_class_for(mode, build: build) : (build ? (own_trace_modes[mode] = build_trace_mode(mode)) : nil))
+      def trace_class_for(mode, build: false)
+        if (trace_class = own_trace_modes[mode])
+          trace_class
+        elsif superclass.respond_to?(:trace_class_for) && (trace_class = superclass.trace_class_for(mode, build: false))
+          trace_class
+        elsif build
+          own_trace_modes[mode] = build_trace_mode(mode)
+        else
+          nil
+        end
       end
 
       # Configure `trace_class` to be used whenever `context: { trace_mode: mode_name }` is requested.
@@ -211,20 +218,24 @@ module GraphQL
             include DefaultTraceClass
           end
         when :default_backtrace
-          schema_base_class = trace_class_for(:default)
+          schema_base_class = trace_class_for(:default, build: true)
           Class.new(schema_base_class) do
             include(GraphQL::Backtrace::Trace)
           end
         else
           # First, see if the superclass has a custom-defined class for this.
           # Then, if it doesn't, use this class's default trace
-          base_class = (superclass.respond_to?(:trace_class_for) && superclass.trace_class_for(mode, build: false)) || trace_class_for(:default)
+          base_class = (superclass.respond_to?(:trace_class_for) && superclass.trace_class_for(mode)) || trace_class_for(:default, build: true)
           # Prepare the default trace class if it hasn't been initialized yet
           base_class ||= (own_trace_modes[:default] = build_trace_mode(:default))
           mods = trace_modules_for(mode)
           if base_class < DefaultTraceClass
             mods = trace_modules_for(:default) + mods
           end
+          # Copy the existing default options into this mode's options
+          default_options = trace_options_for(:default)
+          add_trace_options_for(mode, default_options)
+
           Class.new(base_class) do
             mods.any? && include(*mods)
           end
@@ -632,6 +643,17 @@ module GraphQL
         end
       end
 
+      # A limit on the number of tokens to accept on incoming query strings.
+      # Use this to prevent parsing maliciously-large query strings.
+      # @return [nil, Integer]
+      def max_query_string_tokens(new_max_tokens = NOT_CONFIGURED)
+        if NOT_CONFIGURED.equal?(new_max_tokens)
+          defined?(@max_query_string_tokens) ? @max_query_string_tokens : find_inherited_value(:max_query_string_tokens)
+        else
+          @max_query_string_tokens = new_max_tokens
+        end
+      end
+
       def default_page_size(new_default_page_size = nil)
         if new_default_page_size
           @default_page_size = new_default_page_size
@@ -640,27 +662,39 @@ module GraphQL
         end
       end
 
-      def query_execution_strategy(new_query_execution_strategy = nil)
+      def query_execution_strategy(new_query_execution_strategy = nil, deprecation_warning: true)
+        if deprecation_warning
+          warn "GraphQL::Schema.query_execution_strategy is deprecated without replacement. Use `GraphQL::Query.new` directly to create and execute a custom query instead."
+          warn "  #{caller(1, 1).first}"
+        end
         if new_query_execution_strategy
           @query_execution_strategy = new_query_execution_strategy
         else
-          @query_execution_strategy || find_inherited_value(:query_execution_strategy, self.default_execution_strategy)
+          @query_execution_strategy || (superclass.respond_to?(:query_execution_strategy) ? superclass.query_execution_strategy(deprecation_warning: false) : self.default_execution_strategy)
         end
       end
 
-      def mutation_execution_strategy(new_mutation_execution_strategy = nil)
+      def mutation_execution_strategy(new_mutation_execution_strategy = nil, deprecation_warning: true)
+        if deprecation_warning
+          warn "GraphQL::Schema.mutation_execution_strategy is deprecated without replacement. Use `GraphQL::Query.new` directly to create and execute a custom query instead."
+            warn "  #{caller(1, 1).first}"
+        end
         if new_mutation_execution_strategy
           @mutation_execution_strategy = new_mutation_execution_strategy
         else
-          @mutation_execution_strategy || find_inherited_value(:mutation_execution_strategy, self.default_execution_strategy)
+          @mutation_execution_strategy || (superclass.respond_to?(:mutation_execution_strategy) ? superclass.mutation_execution_strategy(deprecation_warning: false) : self.default_execution_strategy)
         end
       end
 
-      def subscription_execution_strategy(new_subscription_execution_strategy = nil)
+      def subscription_execution_strategy(new_subscription_execution_strategy = nil, deprecation_warning: true)
+        if deprecation_warning
+          warn "GraphQL::Schema.subscription_execution_strategy is deprecated without replacement. Use `GraphQL::Query.new` directly to create and execute a custom query instead."
+          warn "  #{caller(1, 1).first}"
+        end
         if new_subscription_execution_strategy
           @subscription_execution_strategy = new_subscription_execution_strategy
         else
-          @subscription_execution_strategy || find_inherited_value(:subscription_execution_strategy, self.default_execution_strategy)
+          @subscription_execution_strategy || (superclass.respond_to?(:subscription_execution_strategy) ? superclass.subscription_execution_strategy(deprecation_warning: false) : self.default_execution_strategy)
         end
       end
 
@@ -743,6 +777,7 @@ module GraphQL
 
       def error_bubbling(new_error_bubbling = nil)
         if !new_error_bubbling.nil?
+          warn("error_bubbling(#{new_error_bubbling.inspect}) is deprecated; the default value of `false` will be the only option in GraphQL-Ruby 3.0")
           @error_bubbling = new_error_bubbling
         else
           @error_bubbling.nil? ? find_inherited_value(:error_bubbling) : @error_bubbling
@@ -814,9 +849,40 @@ module GraphQL
         end
       end
 
+      # @param new_extra_types [Module] Type definitions to include in printing and introspection, even though they aren't referenced in the schema
+      # @return [Array<Module>] Type definitions added to this schema
+      def extra_types(*new_extra_types)
+        if new_extra_types.any?
+          new_extra_types = new_extra_types.flatten
+          @own_extra_types ||= []
+          @own_extra_types.concat(new_extra_types)
+        end
+        inherited_et = find_inherited_value(:extra_types, nil)
+        if inherited_et
+          if @own_extra_types
+            inherited_et + @own_extra_types
+          else
+            inherited_et
+          end
+        else
+          @own_extra_types || EMPTY_ARRAY
+        end
+      end
+
       def orphan_types(*new_orphan_types)
         if new_orphan_types.any?
           new_orphan_types = new_orphan_types.flatten
+          non_object_types = new_orphan_types.reject { |ot| ot.is_a?(Class) && ot < GraphQL::Schema::Object }
+          if non_object_types.any?
+            raise ArgumentError, <<~ERR
+              Only object type classes should be added as `orphan_types(...)`.
+
+              - Remove these no-op types from `orphan_types`: #{non_object_types.map { |t| "#{t.inspect} (#{t.kind.name})"}.join(", ")}
+              - See https://graphql-ruby.org/type_definitions/interfaces.html#orphan-types
+
+              To add other types to your schema, you might want `extra_types`: https://graphql-ruby.org/schema/definition.html#extra-types
+            ERR
+          end
           add_type_and_traverse(new_orphan_types, root: false)
           own_orphan_types.concat(new_orphan_types.flatten)
         end
@@ -1044,6 +1110,12 @@ module GraphQL
       end
 
       def instrument(instrument_step, instrumenter, options = {})
+        warn <<~WARN
+        Schema.instrument is deprecated, use `trace_with` instead: https://graphql-ruby.org/queries/tracing.html"
+          (From `#{self}.instrument(#{instrument_step}, #{instrumenter})` at #{caller(1, 1).first})
+
+        WARN
+        trace_with(Tracing::LegacyHooksTrace)
         own_instrumenters[instrument_step] << instrumenter
       end
 
@@ -1079,8 +1151,12 @@ module GraphQL
         }.freeze
       end
 
-      def tracer(new_tracer)
-        default_trace = trace_class_for(:default)
+      def tracer(new_tracer, silence_deprecation_warning: false)
+        if !silence_deprecation_warning
+          warn("`Schema.tracer(#{new_tracer.inspect})` is deprecated; use module-based `trace_with` instead. See: https://graphql-ruby.org/queries/tracing.html")
+          warn "  #{caller(1, 1).first}"
+        end
+        default_trace = trace_class_for(:default, build: true)
         if default_trace.nil? || !(default_trace < GraphQL::Tracing::CallLegacyTracers)
           trace_with(GraphQL::Tracing::CallLegacyTracers)
         end
@@ -1106,20 +1182,23 @@ module GraphQL
           tc = own_trace_modes[mode] ||= build_trace_mode(mode)
           tc.include(trace_mod)
           own_trace_modules[mode] << trace_mod
-
+          add_trace_options_for(mode, options)
           if mode == :default
             # This module is being added as a default tracer. If any other mode classes
             # have already been created, but get their default behavior from a superclass,
             # Then mix this into this schema's subclass.
             # (But don't mix it into mode classes that aren't default-based.)
             own_trace_modes.each do |other_mode_name, other_mode_class|
-              if other_mode_class < DefaultTraceClass && !(other_mode_class < trace_mod)
-                other_mode_class.include(trace_mod)
+              if other_mode_class < DefaultTraceClass
+                # Don't add it back to the inheritance tree if it's already there
+                if !(other_mode_class < trace_mod)
+                  other_mode_class.include(trace_mod)
+                end
+                # Add any options so they'll be available
+                add_trace_options_for(other_mode_name, options)
               end
             end
           end
-          t_opts = trace_options_for(mode)
-          t_opts.merge!(options)
         end
         nil
       end
@@ -1129,10 +1208,14 @@ module GraphQL
       def trace_options_for(mode)
         @trace_options_for_mode ||= {}
         @trace_options_for_mode[mode] ||= begin
+          # It may be time to create an options hash for a mode that wasn't registered yet.
+          # Mix in the default options in that case.
+          default_options = mode == :default ? EMPTY_HASH : trace_options_for(:default)
+          # Make sure this returns a new object so that other hashes aren't modified later
           if superclass.respond_to?(:trace_options_for)
-            superclass.trace_options_for(mode).dup
+            superclass.trace_options_for(mode).merge(default_options)
           else
-            {}
+            default_options.dup
           end
         end
       end
@@ -1155,15 +1238,17 @@ module GraphQL
             raise ArgumentError, "Can't use `context[:backtrace]` with a custom default trace mode (`#{dm.inspect}`)"
           else
             own_trace_modes[:default_backtrace] ||= build_trace_mode(:default_backtrace)
+            options_trace_mode = :default
             :default_backtrace
           end
         else
           default_trace_mode
         end
 
-        base_trace_options = trace_options_for(trace_mode)
+        options_trace_mode ||= trace_mode
+        base_trace_options = trace_options_for(options_trace_mode)
         trace_options = base_trace_options.merge(options)
-        trace_class_for_mode = trace_class_for(trace_mode) || raise(ArgumentError, "#{self} has no trace class for mode: #{trace_mode.inspect}")
+        trace_class_for_mode = trace_class_for(trace_mode, build: true)
         trace_class_for_mode.new(**trace_options)
       end
 
@@ -1317,6 +1402,12 @@ module GraphQL
 
       private
 
+      def add_trace_options_for(mode, new_options)
+        t_opts = trace_options_for(mode)
+        t_opts.merge!(new_options)
+        nil
+      end
+
       # @param t [Module, Array<Module>]
       # @return [void]
       def add_type_and_traverse(t, root:)
@@ -1378,7 +1469,7 @@ module GraphQL
           else
             @lazy_methods = GraphQL::Execution::Lazy::LazyMethodMap.new
             @lazy_methods.set(GraphQL::Execution::Lazy, :value)
-            @lazy_methods.set(GraphQL::Dataloader::Request, :load)
+            @lazy_methods.set(GraphQL::Dataloader::Request, :load_with_deprecation_warning)
           end
         end
         @lazy_methods

data/lib/graphql/static_validation/literal_validator.rb

@@ -110,7 +110,7 @@ module GraphQL
         # TODO - would be nice to use these to create an error message so the caller knows
         # that required fields are missing
         required_field_names = @warden.arguments(type)
-          .select { |argument| argument.type.kind.non_null? && @warden.get_argument(type, argument.name) }
+          .select { |argument| argument.type.kind.non_null? && !argument.default_value? }
           .map!(&:name)
 
         present_field_names = ast_node.arguments.map(&:name)
@@ -122,7 +122,6 @@ module GraphQL
             arg_type = @warden.get_argument(type, name).type
             recursively_validate(GraphQL::Language::Nodes::NullValue.new(name: name), arg_type)
           end
-
           if type.one_of? && ast_node.arguments.size != 1
             results << Query::InputValidationResult.from_problem("`#{type.graphql_name}` is a OneOf type, so only one argument may be given (instead of #{ast_node.arguments.size})")
           end

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

@@ -35,7 +35,7 @@ module GraphQL
         return unless parent_type && parent_type.kind.input_object?
 
         required_fields = context.warden.arguments(parent_type)
-          .select{|arg| arg.type.kind.non_null?}
+          .select{ |arg| arg.type.kind.non_null? && !arg.default_value? }
           .map!(&:graphql_name)
 
         present_fields = ast_node.arguments.map(&:name)

data/lib/graphql/static_validation/validator.rb

@@ -28,6 +28,7 @@ module GraphQL
       # @return [Array<Hash>]
       def validate(query, validate: true, timeout: nil, max_errors: nil)
         query.current_trace.validate(validate: validate, query: query) do
+          begin_t = Time.now
           errors = if validate == false
             []
           else
@@ -52,11 +53,13 @@ module GraphQL
           end
 
           {
+            remaining_timeout: timeout ? (timeout - (Time.now - begin_t)) : nil,
             errors: errors,
           }
         end
       rescue GraphQL::ExecutionError => e
         {
+          remaining_timeout: nil,
           errors: [e],
         }
       end

data/lib/graphql/subscriptions/serialize.rb

@@ -148,6 +148,8 @@ module GraphQL
             { TIMESTAMP_KEY => [obj.class.name, obj.strftime(TIMESTAMP_FORMAT)] }
           elsif obj.is_a?(OpenStruct)
             { OPEN_STRUCT_KEY => dump_value(obj.to_h) }
+          elsif defined?(ActiveRecord::Relation) && obj.is_a?(ActiveRecord::Relation)
+            dump_value(obj.to_a)
           else
             obj
           end

data/lib/graphql/subscriptions.rb

@@ -2,7 +2,6 @@
 require "securerandom"
 require "graphql/subscriptions/broadcast_analyzer"
 require "graphql/subscriptions/event"
-require "graphql/subscriptions/instrumentation"
 require "graphql/subscriptions/serialize"
 require "graphql/subscriptions/action_cable_subscriptions"
 require "graphql/subscriptions/default_subscription_resolve_extension"
@@ -30,8 +29,6 @@ module GraphQL
         raise ArgumentError, "Can't reinstall subscriptions. #{schema} is using #{schema.subscriptions}, can't also add #{self}"
       end
 
-      instrumentation = Subscriptions::Instrumentation.new(schema: schema)
-      defn.instrument(:query, instrumentation)
       options[:schema] = schema
       schema.subscriptions = self.new(**options)
       schema.add_subscription_extension_if_necessary

data/lib/graphql/testing/helpers.rb

@@ -5,10 +5,7 @@ module GraphQL
       # @param schema_class [Class<GraphQL::Schema>]
       # @return [Module] A helpers module which always uses the given schema
       def self.for(schema_class)
-        Module.new do
-          include SchemaHelpers
-          @@schema_class_for_helpers = schema_class
-        end
+        SchemaHelpers.for(schema_class)
       end
 
       class Error < GraphQL::Error
@@ -42,9 +39,9 @@ module GraphQL
         end
       end
 
-      def run_graphql_field(schema, field_path, object, arguments: {}, context: {})
+      def run_graphql_field(schema, field_path, object, arguments: {}, context: {}, ast_node: nil, lookahead: nil)
         type_name, *field_names = field_path.split(".")
-        dummy_query = GraphQL::Query.new(schema, context: context)
+        dummy_query = GraphQL::Query.new(schema, "{ __typename }", context: context)
         query_context = dummy_query.context
         object_type = dummy_query.get_type(type_name) # rubocop:disable Development/ContextIsPassedCop
         if object_type
@@ -60,6 +57,28 @@ module GraphQL
               dummy_query.context.dataloader.run_isolated {
                 field_args = visible_field.coerce_arguments(graphql_result, arguments, query_context)
                 field_args = schema.sync_lazy(field_args)
+                if visible_field.extras.any?
+                  extra_args = {}
+                  visible_field.extras.each do |extra|
+                    extra_args[extra] = case extra
+                    when :ast_node
+                      ast_node ||= GraphQL::Language::Nodes::Field.new(name: visible_field.graphql_name)
+                    when :lookahead
+                      lookahead ||= begin
+                        ast_node ||= GraphQL::Language::Nodes::Field.new(name: visible_field.graphql_name)
+                        Execution::Lookahead.new(
+                          query: dummy_query,
+                          ast_nodes: [ast_node],
+                          field: visible_field,
+                        )
+                      end
+                    else
+                      raise ArgumentError, "This extra isn't supported in `run_graphql_field` yet: `#{extra.inspect}`. Open an issue on GitHub to request it: https://github.com/rmosolgo/graphql-ruby/issues/new"
+                    end
+                  end
+
+                  field_args = field_args.merge_extras(extra_args)
+                end
                 graphql_result = visible_field.resolve(graphql_result, field_args.keyword_arguments, query_context)
                 graphql_result = schema.sync_lazy(graphql_result)
               }
@@ -119,6 +138,13 @@ module GraphQL
           # schema will be added later
           super(nil, *args, **kwargs, &block)
         end
+
+        def self.for(schema_class)
+          Module.new do
+            include SchemaHelpers
+            @@schema_class_for_helpers = schema_class
+          end
+        end
       end
     end
   end