graphql 2.0.21 → 2.0.23

data/lib/graphql/language/lexer.rb

@@ -95,12 +95,14 @@ module GraphQL
           previous_token: nil,
         }
 
-        unless string.valid_encoding?
-          emit(:BAD_UNICODE_ESCAPE, 0, 0, meta, string)
+        value = string.dup.force_encoding(Encoding::UTF_8)
+
+        unless value.valid_encoding?
+          emit(:BAD_UNICODE_ESCAPE, 0, 0, meta, value)
           return meta[:tokens]
         end
 
-        scan = StringScanner.new string
+        scan = StringScanner.new value
 
         while !scan.eos?
           pos = scan.pos

data/lib/graphql/language/printer.rb

@@ -131,7 +131,7 @@ module GraphQL
         "$#{variable_identifier.name}".dup
       end
 
-      def print_schema_definition(schema)
+      def print_schema_definition(schema, extension: false)
         has_conventional_names = (schema.query.nil? || schema.query == 'Query') &&
           (schema.mutation.nil? || schema.mutation == 'Mutation') &&
           (schema.subscription.nil? || schema.subscription == 'Subscription')
@@ -140,7 +140,7 @@ module GraphQL
           return
         end
 
-        out = "schema".dup
+        out = extension ? "extend schema".dup : "schema".dup
         if schema.directives.any?
           schema.directives.each do |dir|
             out << "\n  "
@@ -164,14 +164,14 @@ module GraphQL
         out
       end
 
-      def print_scalar_type_definition(scalar_type)
-        out = print_description(scalar_type)
+      def print_scalar_type_definition(scalar_type, extension: false)
+        out = extension ? "extend ".dup : print_description(scalar_type)
         out << "scalar #{scalar_type.name}"
         out << print_directives(scalar_type.directives)
       end
 
-      def print_object_type_definition(object_type)
-        out = print_description(object_type)
+      def print_object_type_definition(object_type, extension: false)
+        out = extension ? "extend ".dup : print_description(object_type)
         out << "type #{object_type.name}"
         out << print_implements(object_type) unless object_type.interfaces.empty?
         out << print_directives(object_type.directives)
@@ -210,23 +210,23 @@ module GraphQL
         out << print_directives(field.directives)
       end
 
-      def print_interface_type_definition(interface_type)
-        out = print_description(interface_type)
+      def print_interface_type_definition(interface_type, extension: false)
+        out = extension ? "extend ".dup : print_description(interface_type)
         out << "interface #{interface_type.name}"
         out << print_implements(interface_type) if interface_type.interfaces.any?
         out << print_directives(interface_type.directives)
         out << print_field_definitions(interface_type.fields)
       end
 
-      def print_union_type_definition(union_type)
-        out = print_description(union_type)
+      def print_union_type_definition(union_type, extension: false)
+        out = extension ? "extend ".dup : print_description(union_type)
         out << "union #{union_type.name}"
         out << print_directives(union_type.directives)
         out << " = " + union_type.types.map(&:name).join(" | ")
       end
 
-      def print_enum_type_definition(enum_type)
-        out = print_description(enum_type)
+      def print_enum_type_definition(enum_type, extension: false)
+        out = extension ? "extend ".dup : print_description(enum_type)
         out << "enum #{enum_type.name}#{print_directives(enum_type.directives)} {\n"
         enum_type.values.each.with_index do |value, i|
           out << print_description(value, indent: '  ', first_in_block: i == 0)
@@ -241,8 +241,8 @@ module GraphQL
         out << "\n"
       end
 
-      def print_input_object_type_definition(input_object_type)
-        out = print_description(input_object_type)
+      def print_input_object_type_definition(input_object_type, extension: false)
+        out = extension ? "extend ".dup : print_description(input_object_type)
         out << "input #{input_object_type.name}"
         out << print_directives(input_object_type.directives)
         if !input_object_type.fields.empty?
@@ -347,24 +347,38 @@ module GraphQL
           print_variable_identifier(node)
         when Nodes::SchemaDefinition
           print_schema_definition(node)
+        when Nodes::SchemaExtension
+          print_schema_definition(node, extension: true)
         when Nodes::ScalarTypeDefinition
           print_scalar_type_definition(node)
+        when Nodes::ScalarTypeExtension
+          print_scalar_type_definition(node, extension: true)
         when Nodes::ObjectTypeDefinition
           print_object_type_definition(node)
+        when Nodes::ObjectTypeExtension
+          print_object_type_definition(node, extension: true)
         when Nodes::InputValueDefinition
           print_input_value_definition(node)
         when Nodes::FieldDefinition
           print_field_definition(node)
         when Nodes::InterfaceTypeDefinition
           print_interface_type_definition(node)
+        when Nodes::InterfaceTypeExtension
+          print_interface_type_definition(node, extension: true)
         when Nodes::UnionTypeDefinition
           print_union_type_definition(node)
+        when Nodes::UnionTypeExtension
+          print_union_type_definition(node, extension: true)
         when Nodes::EnumTypeDefinition
           print_enum_type_definition(node)
+        when Nodes::EnumTypeExtension
+          print_enum_type_definition(node, extension: true)
         when Nodes::EnumValueDefinition
           print_enum_value_definition(node)
         when Nodes::InputObjectTypeDefinition
           print_input_object_type_definition(node)
+        when Nodes::InputObjectTypeExtension
+          print_input_object_type_definition(node, extension: true)
         when Nodes::DirectiveDefinition
           print_directive_definition(node)
         when FalseClass, Float, Integer, NilClass, String, TrueClass, Symbol

data/lib/graphql/query/context.rb

@@ -227,7 +227,8 @@ module GraphQL
             current_path
           else
             (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
-              (current_runtime_state.public_send(key))
+              (query_runtime_state = current_runtime_state[@query]) &&
+              (query_runtime_state.public_send(key))
           end
         else
           # not found
@@ -237,10 +238,12 @@ module GraphQL
 
       def current_path
         current_runtime_state = Thread.current[:__graphql_runtime_info]
-        path = current_runtime_state &&
-          (result = current_runtime_state.current_result) &&
+        query_runtime_state = current_runtime_state && current_runtime_state[@query]
+
+        path = query_runtime_state &&
+          (result = query_runtime_state.current_result) &&
           (result.path)
-        if path && (rn = current_runtime_state.current_result_name)
+        if path && (rn = query_runtime_state.current_result_name)
           path = path.dup
           path.push(rn)
         end
@@ -260,7 +263,8 @@ module GraphQL
       def fetch(key, default = UNSPECIFIED_FETCH_DEFAULT)
         if RUNTIME_METADATA_KEYS.include?(key)
           (runtime = Thread.current[:__graphql_runtime_info]) &&
-            (runtime.public_send(key))
+            (query_runtime_state = runtime[@query]) &&
+            (query_runtime_state.public_send(key))
         elsif @scoped_context.key?(key)
           scoped_context[key]
         elsif @provided_values.key?(key)
@@ -277,8 +281,13 @@ module GraphQL
       def dig(key, *other_keys)
         if RUNTIME_METADATA_KEYS.include?(key)
           (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
-            (obj = current_runtime_state.public_send(key)) &&
-            obj.dig(*other_keys)
+            (query_runtime_state = current_runtime_state[@query]) &&
+            (obj = query_runtime_state.public_send(key)) &&
+            if other_keys.empty?
+              obj
+            else
+              obj.dig(*other_keys)
+            end
         elsif @scoped_context.key?(key)
           @scoped_context.dig(key, *other_keys)
         else

data/lib/graphql/query/null_context.rb

@@ -3,35 +3,27 @@ module GraphQL
   class Query
     # This object can be `ctx` in places where there is no query
     class NullContext
-      class NullWarden < GraphQL::Schema::Warden
-        def visible_field?(field, ctx); true; end
-        def visible_argument?(arg, ctx); true; end
-        def visible_type?(type, ctx); true; end
-        def visible_enum_value?(ev, ctx); true; end
-        def visible_type_membership?(tm, ctx); true; end
-      end
-
       class NullQuery
+        def after_lazy(value)
+          yield(value)
+        end
       end
 
       class NullSchema < GraphQL::Schema
       end
 
+      extend Forwardable
+
       attr_reader :schema, :query, :warden, :dataloader
+      def_delegators GraphQL::EmptyObjects::EMPTY_HASH, :[], :fetch, :dig, :key?
 
       def initialize
         @query = NullQuery.new
         @dataloader = GraphQL::Dataloader::NullDataloader.new
         @schema = NullSchema
-        @warden = NullWarden.new(
-          GraphQL::Filter.new(silence_deprecation_warning: true),
-          context: self,
-          schema: @schema,
-        )
+        @warden = Schema::Warden::NullWarden.new(context: self, schema: @schema)
       end
 
-      def [](key); end
-
       def interpreter?
         true
       end
@@ -39,13 +31,11 @@ module GraphQL
       class << self
         extend Forwardable
 
-        def [](key); end
-
         def instance
           @instance ||= self.new
         end
 
-        def_delegators :instance, :query, :warden, :schema, :interpreter?, :dataloader
+        def_delegators :instance, :query, :warden, :schema, :interpreter?, :dataloader, :[], :fetch, :dig, :key?
       end
     end
   end

data/lib/graphql/query.rb

@@ -87,7 +87,9 @@ module GraphQL
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
       @schema = schema
-      @filter = schema.default_filter.merge(except: except, only: only)
+      if only || except
+        merge_filters(except: except, only: only)
+      end
       @context = schema.context_class.new(query: self, object: root_value, values: context)
       @warden = warden
       @subscription_topic = subscription_topic
@@ -100,7 +102,7 @@ module GraphQL
 
       # Support `ctx[:backtrace] = true` for wrapping backtraces
       if context && context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
-        if schema.trace_class <= GraphQL::Tracing::LegacyTrace
+        if schema.trace_class <= GraphQL::Tracing::CallLegacyTracers
           context_tracers += [GraphQL::Backtrace::Tracer]
           @tracers << GraphQL::Backtrace::Tracer
         elsif !(current_trace.class <= GraphQL::Backtrace::Trace)
@@ -108,8 +110,8 @@ module GraphQL
         end
       end
 
-      if context_tracers.any? && !(schema.trace_class <= GraphQL::Tracing::LegacyTrace)
-        raise ArgumentError, "context[:tracers] are not supported without `trace_class(GraphQL::Tracing::LegacyTrace)` in the schema configuration, please add it."
+      if context_tracers.any? && !(schema.trace_class <= GraphQL::Tracing::CallLegacyTracers)
+        raise ArgumentError, "context[:tracers] are not supported without `trace_with(GraphQL::Tracing::CallLegacyTracers)` in the schema configuration, please add it."
       end
 
 
@@ -151,11 +153,6 @@ module GraphQL
 
       @result_values = nil
       @executed = false
-
-      # TODO add a general way to define schema-level filters
-      if @schema.respond_to?(:visible?)
-        merge_filters(only: @schema.method(:visible?))
-      end
     end
 
     # If a document was provided to `GraphQL::Schema#execute` instead of the raw query string, we will need to get it from the document
@@ -171,7 +168,7 @@ module GraphQL
 
     # @return [GraphQL::Tracing::Trace]
     def current_trace
-      @current_trace ||= multiplex ? multiplex.current_trace : schema.new_trace(multiplex: multiplex, query: self)
+      @current_trace ||= context[:trace] || (multiplex ? multiplex.current_trace : schema.new_trace(multiplex: multiplex, query: self))
     end
 
     def subscription_update?
@@ -347,6 +344,7 @@ module GraphQL
       if @prepared_ast
         raise "Can't add filters after preparing the query"
       else
+        @filter ||= @schema.default_filter
         @filter = @filter.merge(only: only, except: except)
       end
       nil
@@ -361,6 +359,18 @@ module GraphQL
       schema.handle_or_reraise(context, err)
     end
 
+    def after_lazy(value, &block)
+      if !defined?(@runtime_instance)
+        @runtime_instance = context.namespace(:interpreter_runtime)[:runtime]
+      end
+
+      if @runtime_instance
+        @runtime_instance.minimal_after_lazy(value, &block)
+      else
+        @schema.after_lazy(value, &block)
+      end
+    end
+
     private
 
     def find_operation(operations, operation_name)
@@ -375,7 +385,7 @@ module GraphQL
 
     def prepare_ast
       @prepared_ast = true
-      @warden ||= GraphQL::Schema::Warden.new(@filter, schema: @schema, context: @context)
+      @warden ||= @schema.warden_class.new(@filter, schema: @schema, context: @context)
       parse_error = nil
       @document ||= begin
         if query_string

data/lib/graphql/schema/always_visible.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class AlwaysVisible
+      def self.use(schema, **opts)
+        schema.warden_class = GraphQL::Schema::Warden::NullWarden
+      end
+    end
+  end
+end

data/lib/graphql/schema/argument.rb

@@ -198,8 +198,8 @@ module GraphQL
 
       def statically_coercible?
         return @statically_coercible if defined?(@statically_coercible)
-
-        @statically_coercible = !@prepare.is_a?(String) && !@prepare.is_a?(Symbol)
+        requires_parent_object = @prepare.is_a?(String) || @prepare.is_a?(Symbol) || @own_validators
+        @statically_coercible = !requires_parent_object
       end
 
       # Apply the {prepare} configuration to `value`, using methods from `obj`.
@@ -264,7 +264,7 @@ module GraphQL
 
         # If this isn't lazy, then the block returns eagerly and assigns the result here
         # If it _is_ lazy, then we write the lazy to the hash, then update it later
-        argument_values[arg_key] = context.schema.after_lazy(coerced_value) do |resolved_coerced_value|
+        argument_values[arg_key] = context.query.after_lazy(coerced_value) do |resolved_coerced_value|
           owner.validate_directive_argument(self, resolved_coerced_value)
           prepared_value = begin
             prepare_value(parent_object, resolved_coerced_value, context: context)
@@ -281,7 +281,7 @@ module GraphQL
           end
 
           maybe_loaded_value = loaded_value || prepared_value
-          context.schema.after_lazy(maybe_loaded_value) do |resolved_loaded_value|
+          context.query.after_lazy(maybe_loaded_value) do |resolved_loaded_value|
             # TODO code smell to access such a deeply-nested constant in a distant module
             argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
               value: resolved_loaded_value,
@@ -303,7 +303,7 @@ module GraphQL
           else
             load_method_owner.public_send(arg_load_method, coerced_value)
           end
-          context.schema.after_lazy(custom_loaded_value) do |custom_value|
+          context.query.after_lazy(custom_loaded_value) do |custom_value|
             if loads
               if type.list?
                 loaded_values = custom_value.each_with_index.map { |custom_val, idx|

data/lib/graphql/schema/enum_value.rb

@@ -34,7 +34,7 @@ module GraphQL
         @graphql_name = graphql_name.to_s
         GraphQL::NameValidator.validate!(@graphql_name)
         @description = desc || description
-        @value = value === NOT_CONFIGURED ? @graphql_name : value
+        @value = value == NOT_CONFIGURED ? @graphql_name : value
         if deprecation_reason
           self.deprecation_reason = deprecation_reason
         end

data/lib/graphql/schema/field/connection_extension.rb

@@ -26,7 +26,7 @@ module GraphQL
           # rename some inputs to avoid conflicts inside the block
           maybe_lazy = value
           value = nil
-          context.schema.after_lazy(maybe_lazy) do |resolved_value|
+          context.query.after_lazy(maybe_lazy) do |resolved_value|
             value = resolved_value
             if value.is_a? GraphQL::ExecutionError
               # This isn't even going to work because context doesn't have ast_node anymore

data/lib/graphql/schema/field.rb

@@ -235,7 +235,7 @@ module GraphQL
         @name = -(camelize ? Member::BuildType.camelize(name_s) : name_s)
 
         @description = description
-        @type = @owner_type = @own_validators = @own_directives = @own_arguments = nil # these will be prepared later if necessary
+        @type = @owner_type = @own_validators = @own_directives = @own_arguments = @arguments_statically_coercible = nil # these will be prepared later if necessary
 
         self.deprecation_reason = deprecation_reason
 
@@ -661,7 +661,7 @@ module GraphQL
 
         Schema::Validator.validate!(validators, application_object, query_ctx, args)
 
-        query_ctx.schema.after_lazy(self.authorized?(application_object, args, query_ctx)) do |is_authorized|
+        query_ctx.query.after_lazy(self.authorized?(application_object, args, query_ctx)) do |is_authorized|
           if is_authorized
             with_extensions(object, args, query_ctx) do |obj, ruby_kwargs|
               method_args = ruby_kwargs
@@ -810,6 +810,17 @@ ERR
         end
       end
 
+      class ExtendedState
+        def initialize(args, object)
+          @arguments = args
+          @object = object
+          @memos = nil
+          @added_extras = nil
+        end
+
+        attr_accessor :arguments, :object, :memos, :added_extras
+      end
+
       # Wrap execution with hooks.
       # Written iteratively to avoid big stack traces.
       # @return [Object] Whatever the
@@ -820,20 +831,20 @@ ERR
           # This is a hack to get the _last_ value for extended obj and args,
           # in case one of the extensions doesn't `yield`.
           # (There's another implementation that uses multiple-return, but I'm wary of the perf cost of the extra arrays)
-          extended = { args: args, obj: obj, memos: nil, added_extras: nil }
+          extended = ExtendedState.new(args, obj)
           value = run_extensions_before_resolve(obj, args, ctx, extended) do |obj, args|
-            if (added_extras = extended[:added_extras])
+            if (added_extras = extended.added_extras)
               args = args.dup
               added_extras.each { |e| args.delete(e) }
             end
             yield(obj, args)
           end
 
-          extended_obj = extended[:obj]
-          extended_args = extended[:args]
-          memos = extended[:memos] || EMPTY_HASH
+          extended_obj = extended.object
+          extended_args = extended.arguments # rubocop:disable Development/ContextIsPassedCop
+          memos = extended.memos || EMPTY_HASH
 
-          ctx.schema.after_lazy(value) do |resolved_value|
+          ctx.query.after_lazy(value) do |resolved_value|
             idx = 0
             @extensions.each do |ext|
               memo = memos[idx]
@@ -851,17 +862,17 @@ ERR
         if extension
           extension.resolve(object: obj, arguments: args, context: ctx) do |extended_obj, extended_args, memo|
             if memo
-              memos = extended[:memos] ||= {}
+              memos = extended.memos ||= {}
               memos[idx] = memo
             end
 
             if (extras = extension.added_extras)
-              ae = extended[:added_extras] ||= []
+              ae = extended.added_extras ||= []
               ae.concat(extras)
             end
 
-            extended[:obj] = extended_obj
-            extended[:args] = extended_args
+            extended.object = extended_obj
+            extended.arguments = extended_args
             run_extensions_before_resolve(extended_obj, extended_args, ctx, extended, idx: idx + 1) { |o, a| yield(o, a) }
           end
         else

data/lib/graphql/schema/input_object.rb

@@ -211,7 +211,7 @@ module GraphQL
 
           arguments = coerce_arguments(nil, value, ctx)
 
-          ctx.schema.after_lazy(arguments) do |resolved_arguments|
+          ctx.query.after_lazy(arguments) do |resolved_arguments|
             if resolved_arguments.is_a?(GraphQL::Error)
               raise resolved_arguments
             else

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

@@ -51,7 +51,7 @@ module GraphQL
               class_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{method_owner}load_#{arg_defn.keyword}(values, context = nil)
                 argument = get_argument("#{arg_defn.graphql_name}")
-                (context || self.context).schema.after_lazy(values) do |values2|
+                (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
               end
@@ -320,9 +320,11 @@ module GraphQL
         end
 
         def arguments_statically_coercible?
-          return @arguments_statically_coercible if defined?(@arguments_statically_coercible)
-
-          @arguments_statically_coercible = all_argument_definitions.all?(&:statically_coercible?)
+          if defined?(@arguments_statically_coercible) && !@arguments_statically_coercible.nil?
+            @arguments_statically_coercible
+          else
+            @arguments_statically_coercible = all_argument_definitions.all?(&:statically_coercible?)
+          end
         end
 
         module ArgumentClassAccessor
@@ -363,7 +365,7 @@ module GraphQL
           end
 
           def authorize_application_object(argument, id, context, loaded_application_object)
-            context.schema.after_lazy(loaded_application_object) do |application_object|
+            context.query.after_lazy(loaded_application_object) do |application_object|
               if application_object.nil?
                 err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
                 load_application_object_failed(err)
@@ -371,7 +373,7 @@ module GraphQL
               # Double-check that the located object is actually of this type
               # (Don't want to allow arbitrary access to objects this way)
               maybe_lazy_resolve_type = context.schema.resolve_type(argument.loads, application_object, context)
-              context.schema.after_lazy(maybe_lazy_resolve_type) do |resolve_type_result|
+              context.query.after_lazy(maybe_lazy_resolve_type) do |resolve_type_result|
                 if resolve_type_result.is_a?(Array) && resolve_type_result.size == 2
                   application_object_type, application_object = resolve_type_result
                 else
@@ -386,7 +388,7 @@ module GraphQL
                   # This object was loaded successfully
                   # and resolved to the right type,
                   # now apply the `.authorized?` class method if there is one
-                  context.schema.after_lazy(application_object_type.authorized?(application_object, context)) do |authed|
+                  context.query.after_lazy(application_object_type.authorized?(application_object, context)) do |authed|
                     if authed
                       application_object
                     else

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

data/lib/graphql/schema/timeout.rb

@@ -90,7 +90,7 @@ module GraphQL
       # The default implementation returns the `max_seconds:` value from installing this plugin.
       #
       # @param query [GraphQL::Query] The query that's about to run
-      # @return [Integer, false] The number of seconds after which to interrupt query execution and call {#handle_error}, or `false` to bypass the timeout.
+      # @return [Numeric, false] The number of seconds after which to interrupt query execution and call {#handle_error}, or `false` to bypass the timeout.
       def max_seconds(query)
         @max_seconds
       end