graphql 1.11.2 → 1.11.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bafdf456b47766daa370e9f8559e2f525b37d24b6f5a253742eba71759428f29
-  data.tar.gz: f2dc55cb9c2777104f23358a27e01328ed4b4df5334ce237e9af1cae731c3ab7
+  metadata.gz: af3eaf2a85e27ab7a366e27a98d42e4372b93c7590c99fb6fb12fccb48ef37f9
+  data.tar.gz: 62be23c2f74539be298db79081b148db5d004325ef6ae6f1b007711659110a01
 SHA512:
-  metadata.gz: f7120485f538e60577a55b9674cb21e89785d10becfb5545e8412c284547b4c066c3c7abff15b53edca990cb49fd659eeb0df16e84f6bfb511aca89dd41d2834
-  data.tar.gz: a48a2c59655e72c44d711f69cd94c7649a0ada18e1dba50cabadaa8a2748b12021ed7f03a6accca78bfba4aab93de2d37cf0b5e119f3f08a12a7d9784667af15
+  metadata.gz: f12858fd3c28da572082443e022ed2a5281bda7eda01a35b4c6bee65273b5744ae43904c5bf6202a5d461d67de6ee1ec9d1210a121181d5876a3aee3f37b4f1e
+  data.tar.gz: ed4f7ba1b52e9526d4f4a630f2ca06234816bd6be7522e29a98015a8bfa94a8bccdf98a03139ef9f45b266a8f62cb9d922c93ddebf797125d91d04a2203a4aec

data/lib/generators/graphql/core.rb

@@ -41,6 +41,14 @@ module Graphql
         end
       end
 
+      def module_namespacing_when_supported
+        if defined?(module_namespacing)
+          module_namespacing { yield }
+        else
+          yield
+        end
+      end
+
       private
 
       def schema_name

data/lib/generators/graphql/object_generator.rb

@@ -40,6 +40,8 @@ module Graphql
         case type_expression
         when "Text"
           ["String", null]
+        when "Decimal"
+          ["Float", null]
         when "DateTime", "Datetime"
           ["GraphQL::Types::ISO8601DateTime", null]
         when "Date"

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

@@ -1,4 +1,6 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseArgument < GraphQL::Schema::Argument
   end
 end
+<% end -%>

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

@@ -1,4 +1,6 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseEnum < GraphQL::Schema::Enum
   end
 end
+<% end -%>

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

@@ -1,5 +1,7 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseField < GraphQL::Schema::Field
     argument_class Types::BaseArgument
   end
 end
+<% end -%>

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

@@ -1,5 +1,7 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseInputObject < GraphQL::Schema::InputObject
     argument_class Types::BaseArgument
   end
 end
+<% end -%>

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

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Types
   module BaseInterface
     include GraphQL::Schema::Interface
@@ -5,3 +6,4 @@ module Types
     field_class Types::BaseField
   end
 end
+<% end -%>

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

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Mutations
   class BaseMutation < GraphQL::Schema::RelayClassicMutation
     argument_class Types::BaseArgument
@@ -6,3 +7,4 @@ module Mutations
     object_class Types::BaseObject
   end
 end
+<% end -%>

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

@@ -1,5 +1,7 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseObject < GraphQL::Schema::Object
     field_class Types::BaseField
   end
 end
+<% end -%>

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

@@ -1,4 +1,6 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseScalar < GraphQL::Schema::Scalar
   end
 end
+<% end -%>

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

@@ -1,4 +1,6 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseUnion < GraphQL::Schema::Union
   end
 end
+<% end -%>

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

@@ -1,5 +1,7 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class <%= type_ruby_name.split('::')[-1] %> < Types::BaseEnum
 <% prepared_values.each do |v| %>    value "<%= v[0] %>"<%= v.length > 1 ? ", value: #{v[1]}" : "" %>
 <% end %>  end
 end
+<% end -%>

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

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 class GraphqlController < ApplicationController
   # If accessing from outside this domain, nullify the session
   # This allows for outside API access while preventing CSRF attacks,
@@ -48,3 +49,4 @@ class GraphqlController < ApplicationController
     render json: { errors: [{ message: e.message, backtrace: e.backtrace }], data: {} }, status: 500
   end
 end
+<% end -%>

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

@@ -1,6 +1,8 @@
+<% module_namespacing_when_supported do -%>
 module Types
   module <%= type_ruby_name.split('::')[-1] %>
     include Types::BaseInterface
 <% normalized_fields.each do |f| %>    <%= f.to_ruby %>
 <% end %>  end
 end
+<% end -%>

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

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Loaders
   class <%= class_name %> < GraphQL::Batch::Loader
     # Define `initialize` to store grouping arguments, eg
@@ -15,3 +16,4 @@ module Loaders
     end
   end
 end
+<% end -%>

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

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Mutations
   class <%= mutation_name %> < BaseMutation
     # TODO: define return fields
@@ -12,3 +13,4 @@ module Mutations
     # end
   end
 end
+<% end -%>

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

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class MutationType < Types::BaseObject
     # TODO: remove me
@@ -8,3 +9,4 @@ module Types
     end
   end
 end
+<% end -%>

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

@@ -1,6 +1,8 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class <%= type_ruby_name.split('::')[-1] %> < Types::BaseObject
 <% if options.node %>    implements GraphQL::Relay::Node.interface
 <% end %><% normalized_fields.each do |f| %>    <%= f.to_ruby %>
 <% end %>  end
 end
+<% end -%>

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

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class QueryType < Types::BaseObject
     # Add root-level fields here.
@@ -13,3 +14,4 @@ module Types
     field :node, field: GraphQL::Relay::Node.field
 <% end %>  end
 end
+<% end -%>

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

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class <%= type_ruby_name.split('::')[-1] %> < Types::BaseScalar
     def self.coerce_input(input_value, context)
@@ -11,3 +12,4 @@ module Types
     end
   end
 end
+<% end -%>

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

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 class <%= schema_name %> < GraphQL::Schema
   query(Types::QueryType)
 
@@ -38,3 +39,4 @@ class <%= schema_name %> < GraphQL::Schema
   # GraphQL::Batch setup:
   use GraphQL::Batch
 <% end %>end
+<% end -%>

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

@@ -1,5 +1,7 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class <%= type_ruby_name.split('::')[-1] %> < Types::BaseUnion
-<% if possible_types.any? %>    possible_types [<%= normalized_possible_types.join(", ") %>]
+<% if possible_types.any? %>    possible_types <%= normalized_possible_types.join(", ") %>
 <% end %>  end
 end
+<% end -%>

data/lib/graphql.rb

@@ -21,6 +21,14 @@ module GraphQL
   class RequiredImplementationMissingError < Error
   end
 
+  class << self
+    def default_parser
+      @default_parser ||= GraphQL::Language::Parser
+    end
+
+    attr_writer :default_parser
+  end
+
   # Turn a query string or schema definition into an AST
   # @param graphql_string [String] a GraphQL query string or schema definition
   # @return [GraphQL::Language::Nodes::Document]
@@ -61,6 +69,14 @@ module GraphQL
       end
     end
   end
+
+  module StringMatchBackport
+    refine String do
+      def match?(pattern)
+        self =~ pattern
+      end
+    end
+  end
 end
 
 # Order matters for these:
@@ -113,6 +129,7 @@ require "graphql/introspection"
 require "graphql/analysis_error"
 require "graphql/coercion_error"
 require "graphql/invalid_name_error"
+require "graphql/integer_decoding_error"
 require "graphql/integer_encoding_error"
 require "graphql/string_encoding_error"
 require "graphql/internal_representation"

data/lib/graphql/argument.rb

@@ -3,14 +3,14 @@ module GraphQL
   # @api deprecated
   class Argument
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, :type, :description, :default_value, :as, :prepare, :method_access
+    accepts_definitions :name, :type, :description, :default_value, :as, :prepare, :method_access, :deprecation_reason
     attr_reader :default_value
-    attr_accessor :description, :name, :as
+    attr_accessor :description, :name, :as, :deprecation_reason
     attr_accessor :ast_node
     attr_accessor :method_access
     alias :graphql_name :name
 
-    ensure_defined(:name, :description, :default_value, :type=, :type, :as, :expose_as, :prepare, :method_access)
+    ensure_defined(:name, :description, :default_value, :type=, :type, :as, :expose_as, :prepare, :method_access, :deprecation_reason)
 
     # @api private
     module DefaultPrepare

data/lib/graphql/backtrace/tracer.rb

@@ -15,7 +15,8 @@ module GraphQL
         when "validate", "analyze_query", "execute_query", "execute_query_lazy"
           metadata[:query] || metadata[:queries]
         when "execute_field", "execute_field_lazy"
-          metadata[:context]
+          # The interpreter passes `query:`, legacy passes `context:`
+          metadata[:context] || ((q = metadata[:query]) && q.context)
         else
           # Custom key, no backtrace data for this
           nil

data/lib/graphql/define/assign_global_id_field.rb

@@ -2,9 +2,9 @@
 module GraphQL
   module Define
     module AssignGlobalIdField
-      def self.call(type_defn, field_name)
+      def self.call(type_defn, field_name, **field_kwargs)
         resolve = GraphQL::Relay::GlobalIdResolve.new(type: type_defn)
-        GraphQL::Define::AssignObjectField.call(type_defn, field_name, type: GraphQL::ID_TYPE.to_non_null_type, resolve: resolve)
+        GraphQL::Define::AssignObjectField.call(type_defn, field_name, **field_kwargs, type: GraphQL::ID_TYPE.to_non_null_type, resolve: resolve)
       end
     end
   end

data/lib/graphql/execution/interpreter.rb

@@ -93,6 +93,16 @@ module GraphQL
         tracer.trace("execute_query_lazy", {multiplex: multiplex, query: query}) do
           Interpreter::Resolve.resolve_all(final_values)
         end
+        queries.each do |query|
+          runtime = query.context.namespace(:interpreter)[:runtime]
+          if runtime
+            runtime.delete_interpreter_context(:current_path)
+            runtime.delete_interpreter_context(:current_field)
+            runtime.delete_interpreter_context(:current_object)
+            runtime.delete_interpreter_context(:current_arguments)
+          end
+        end
+        nil
       end
 
       class ListResultFailedError < GraphQL::Error

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

@@ -14,18 +14,33 @@ module GraphQL
         # This hash is the one used at runtime.
         #
         # @return [Hash<Symbol, Object>]
-        attr_reader :keyword_arguments
+        def keyword_arguments
+          @keyword_arguments ||= begin
+            kwargs = {}
+            argument_values.each do |name, arg_val|
+              kwargs[name] = arg_val.value
+            end
+            kwargs
+          end
+        end
 
-        def initialize(keyword_arguments:, argument_values:)
-          @keyword_arguments = keyword_arguments
+        # @param argument_values [nil, Hash{Symbol => ArgumentValue}]
+        def initialize(argument_values:)
           @argument_values = argument_values
+          @empty = argument_values.nil? || argument_values.empty?
         end
 
         # @return [Hash{Symbol => ArgumentValue}]
-        attr_reader :argument_values
+        def argument_values
+          @argument_values ||= {}
+        end
+
+        def empty?
+          @empty
+        end
 
-        def_delegators :@keyword_arguments, :key?, :[], :keys, :each, :values
-        def_delegators :@argument_values, :each_value
+        def_delegators :keyword_arguments, :key?, :[], :fetch, :keys, :each, :values
+        def_delegators :argument_values, :each_value
 
         def inspect
           "#<#{self.class} @keyword_arguments=#{keyword_arguments.inspect}>"

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

@@ -29,11 +29,16 @@ module GraphQL
 
         private
 
+        NO_ARGUMENTS = {}.freeze
+
         NO_VALUE_GIVEN = Object.new
 
         def prepare_args_hash(ast_arg_or_hash_or_value)
           case ast_arg_or_hash_or_value
           when Hash
+            if ast_arg_or_hash_or_value.empty?
+              return NO_ARGUMENTS
+            end
             args_hash = {}
             ast_arg_or_hash_or_value.each do |k, v|
               args_hash[k] = prepare_args_hash(v)
@@ -42,6 +47,9 @@ module GraphQL
           when Array
             ast_arg_or_hash_or_value.map { |v| prepare_args_hash(v) }
           when GraphQL::Language::Nodes::Field, GraphQL::Language::Nodes::InputObject, GraphQL::Language::Nodes::Directive
+            if ast_arg_or_hash_or_value.arguments.empty?
+              return NO_ARGUMENTS
+            end
             args_hash = {}
             ast_arg_or_hash_or_value.arguments.each do |arg|
               v = prepare_args_hash(arg.value)

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

@@ -43,23 +43,24 @@ module GraphQL
         # might be stored up in lazies.
         # @return [void]
         def run_eager
-
           root_operation = query.selected_operation
           root_op_type = root_operation.operation_type || "query"
           root_type = schema.root_type_for_operation(root_op_type)
           path = []
-          @interpreter_context[:current_object] = query.root_value
-          @interpreter_context[:current_path] = path
+          set_all_interpreter_context(query.root_value, nil, nil, path)
           object_proxy = authorized_new(root_type, query.root_value, context, path)
           object_proxy = schema.sync_lazy(object_proxy)
           if object_proxy.nil?
             # Root .authorized? returned false.
             write_in_response(path, nil)
-            nil
           else
             evaluate_selections(path, context.scoped_context, object_proxy, root_type, root_operation.selections, root_operation_type: root_op_type)
-            nil
           end
+          delete_interpreter_context(:current_path)
+          delete_interpreter_context(:current_field)
+          delete_interpreter_context(:current_object)
+          delete_interpreter_context(:current_arguments)
+          nil
         end
 
         def gather_selections(owner_object, owner_type, selections, selections_by_name)
@@ -116,9 +117,10 @@ module GraphQL
           end
         end
 
+        NO_ARGS = {}.freeze
+
         def evaluate_selections(path, scoped_context, owner_object, owner_type, selections, root_operation_type: nil)
-          @interpreter_context[:current_object] = owner_object
-          @interpreter_context[:current_path] = path
+          set_all_interpreter_context(owner_object, nil, nil, path)
           selections_by_name = {}
           gather_selections(owner_object, owner_type, selections, selections_by_name)
           selections_by_name.each do |result_name, field_ast_nodes_or_ast_node|
@@ -157,8 +159,7 @@ module GraphQL
             # to propagate `null`
             set_type_at_path(next_path, return_type)
             # Set this before calling `run_with_directives`, so that the directive can have the latest path
-            @interpreter_context[:current_path] = next_path
-            @interpreter_context[:current_field] = field_defn
+            set_all_interpreter_context(nil, field_defn, nil, next_path)
 
             context.scoped_context = scoped_context
             object = owner_object
@@ -169,44 +170,50 @@ module GraphQL
 
             begin
               kwarg_arguments = arguments(object, field_defn, ast_node)
-            rescue GraphQL::ExecutionError => e
-              continue_value(next_path, e, field_defn, return_type.non_null?, ast_node)
+            rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => e
+              continue_value(next_path, e, owner_type, field_defn, return_type.non_null?, ast_node)
               next
             end
 
             after_lazy(kwarg_arguments, owner: owner_type, field: field_defn, path: next_path, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |resolved_arguments|
-              if resolved_arguments.is_a? GraphQL::ExecutionError
-                continue_value(next_path, resolved_arguments, field_defn, return_type.non_null?, ast_node)
+              case resolved_arguments
+              when GraphQL::ExecutionError, GraphQL::UnauthorizedError
+                continue_value(next_path, resolved_arguments, owner_type, field_defn, return_type.non_null?, ast_node)
                 next
               end
 
-              kwarg_arguments = resolved_arguments.keyword_arguments
-
-              field_defn.extras.each do |extra|
-                case extra
-                when :ast_node
-                  kwarg_arguments[:ast_node] = ast_node
-                when :execution_errors
-                  kwarg_arguments[:execution_errors] = ExecutionErrors.new(context, ast_node, next_path)
-                when :path
-                  kwarg_arguments[:path] = next_path
-                when :lookahead
-                  if !field_ast_nodes
-                    field_ast_nodes = [ast_node]
+              if resolved_arguments.empty? && field_defn.extras.empty?
+                # We can avoid allocating the `{ Symbol => Object }` hash in this case
+                kwarg_arguments = NO_ARGS
+              else
+                kwarg_arguments = resolved_arguments.keyword_arguments
+
+                field_defn.extras.each do |extra|
+                  case extra
+                  when :ast_node
+                    kwarg_arguments[:ast_node] = ast_node
+                  when :execution_errors
+                    kwarg_arguments[:execution_errors] = ExecutionErrors.new(context, ast_node, next_path)
+                  when :path
+                    kwarg_arguments[:path] = next_path
+                  when :lookahead
+                    if !field_ast_nodes
+                      field_ast_nodes = [ast_node]
+                    end
+                    kwarg_arguments[:lookahead] = Execution::Lookahead.new(
+                      query: query,
+                      ast_nodes: field_ast_nodes,
+                      field: field_defn,
+                    )
+                  when :argument_details
+                    kwarg_arguments[:argument_details] = resolved_arguments
+                  else
+                    kwarg_arguments[extra] = field_defn.fetch_extra(extra, context)
                   end
-                  kwarg_arguments[:lookahead] = Execution::Lookahead.new(
-                    query: query,
-                    ast_nodes: field_ast_nodes,
-                    field: field_defn,
-                  )
-                when :argument_details
-                  kwarg_arguments[:argument_details] = resolved_arguments
-                else
-                  kwarg_arguments[extra] = field_defn.fetch_extra(extra, context)
                 end
               end
 
-              @interpreter_context[:current_arguments] = kwarg_arguments
+              set_all_interpreter_context(nil, nil, kwarg_arguments, nil)
 
               # Optimize for the case that field is selected only once
               if field_ast_nodes.nil? || field_ast_nodes.size == 1
@@ -228,12 +235,12 @@ module GraphQL
                   err
                 end
                 after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |inner_result|
-                  continue_value = continue_value(next_path, inner_result, field_defn, return_type.non_null?, ast_node)
+                  continue_value = continue_value(next_path, inner_result, owner_type, field_defn, return_type.non_null?, ast_node)
                   if RawValue === continue_value
                     # Write raw value directly to the response without resolving nested objects
                     write_in_response(next_path, continue_value.resolve)
                   elsif HALT != continue_value
-                    continue_field(next_path, continue_value, field_defn, return_type, ast_node, next_selections, false, object, kwarg_arguments)
+                    continue_field(next_path, continue_value, owner_type, field_defn, return_type, ast_node, next_selections, false, object, kwarg_arguments)
                   end
                 end
               end
@@ -251,10 +258,9 @@ module GraphQL
         end
 
         HALT = Object.new
-        def continue_value(path, value, field, is_non_null, ast_node)
+        def continue_value(path, value, parent_type, field, is_non_null, ast_node)
           if value.nil?
             if is_non_null
-              parent_type = field.owner_type
               err = parent_type::InvalidNullError.new(parent_type, field, value)
               write_invalid_null_in_response(path, err)
             else
@@ -282,7 +288,7 @@ module GraphQL
               err
             end
 
-            continue_value(path, next_value, field, is_non_null, ast_node)
+            continue_value(path, next_value, parent_type, field, is_non_null, ast_node)
           elsif GraphQL::Execution::Execute::SKIP == value
             HALT
           else
@@ -298,49 +304,49 @@ module GraphQL
         # Location information from `path` and `ast_node`.
         #
         # @return [Lazy, Array, Hash, Object] Lazy, Array, and Hash are all traversed to resolve lazy values later
-        def continue_field(path, value, field, type, ast_node, next_selections, is_non_null, owner_object, arguments) # rubocop:disable Metrics/ParameterLists
-          case type.kind.name
+        def continue_field(path, value, owner_type, field, current_type, ast_node, next_selections, is_non_null, owner_object, arguments) # rubocop:disable Metrics/ParameterLists
+          case current_type.kind.name
           when "SCALAR", "ENUM"
-            r = type.coerce_result(value, context)
+            r = current_type.coerce_result(value, context)
             write_in_response(path, r)
             r
           when "UNION", "INTERFACE"
-            resolved_type_or_lazy, resolved_value = resolve_type(type, value, path)
+            resolved_type_or_lazy, resolved_value = resolve_type(current_type, value, path)
             resolved_value ||= value
 
-            after_lazy(resolved_type_or_lazy, owner: type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false) do |resolved_type|
-              possible_types = query.possible_types(type)
+            after_lazy(resolved_type_or_lazy, owner: current_type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false) do |resolved_type|
+              possible_types = query.possible_types(current_type)
 
               if !possible_types.include?(resolved_type)
                 parent_type = field.owner_type
-                err_class = type::UnresolvedTypeError
+                err_class = current_type::UnresolvedTypeError
                 type_error = err_class.new(resolved_value, field, parent_type, resolved_type, possible_types)
                 schema.type_error(type_error, context)
                 write_in_response(path, nil)
                 nil
               else
-                continue_field(path, resolved_value, field, resolved_type, ast_node, next_selections, is_non_null, owner_object, arguments)
+                continue_field(path, resolved_value, owner_type, field, resolved_type, ast_node, next_selections, is_non_null, owner_object, arguments)
               end
             end
           when "OBJECT"
             object_proxy = begin
-              authorized_new(type, value, context, path)
+              authorized_new(current_type, value, context, path)
             rescue GraphQL::ExecutionError => err
               err
             end
-            after_lazy(object_proxy, owner: type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false) do |inner_object|
-              continue_value = continue_value(path, inner_object, field, is_non_null, ast_node)
+            after_lazy(object_proxy, owner: current_type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false) do |inner_object|
+              continue_value = continue_value(path, inner_object, owner_type, field, is_non_null, ast_node)
               if HALT != continue_value
                 response_hash = {}
                 write_in_response(path, response_hash)
-                evaluate_selections(path, context.scoped_context, continue_value, type, next_selections)
+                evaluate_selections(path, context.scoped_context, continue_value, current_type, next_selections)
                 response_hash
               end
             end
           when "LIST"
             response_list = []
             write_in_response(path, response_list)
-            inner_type = type.of_type
+            inner_type = current_type.of_type
             idx = 0
             scoped_context = context.scoped_context
             begin
@@ -352,9 +358,9 @@ module GraphQL
                 set_type_at_path(next_path, inner_type)
                 # This will update `response_list` with the lazy
                 after_lazy(inner_value, owner: inner_type, path: next_path, scoped_context: scoped_context, field: field, owner_object: owner_object, arguments: arguments) do |inner_inner_value|
-                  continue_value = continue_value(next_path, inner_inner_value, field, inner_type.non_null?, ast_node)
+                  continue_value = continue_value(next_path, inner_inner_value, owner_type, field, inner_type.non_null?, ast_node)
                   if HALT != continue_value
-                    continue_field(next_path, continue_value, field, inner_type, ast_node, next_selections, false, owner_object, arguments)
+                    continue_field(next_path, continue_value, owner_type, field, inner_type, ast_node, next_selections, false, owner_object, arguments)
                   end
                 end
               end
@@ -371,12 +377,12 @@ module GraphQL
 
             response_list
           when "NON_NULL"
-            inner_type = type.of_type
+            inner_type = current_type.of_type
             # Don't `set_type_at_path` because we want the static type,
             # we're going to use that to determine whether a `nil` should be propagated or not.
-            continue_field(path, value, field, inner_type, ast_node, next_selections, true, owner_object, arguments)
+            continue_field(path, value, owner_type, field, inner_type, ast_node, next_selections, true, owner_object, arguments)
           else
-            raise "Invariant: Unhandled type kind #{type.kind} (#{type})"
+            raise "Invariant: Unhandled type kind #{current_type.kind} (#{current_type})"
           end
         end
 
@@ -413,6 +419,21 @@ module GraphQL
           true
         end
 
+        def set_all_interpreter_context(object, field, arguments, path)
+          if object
+            @context[:current_object] = @interpreter_context[:current_object] = object
+          end
+          if field
+            @context[:current_field] = @interpreter_context[:current_field] = field
+          end
+          if arguments
+            @context[:current_arguments] = @interpreter_context[:current_arguments] = arguments
+          end
+          if path
+            @context[:current_path] = @interpreter_context[:current_path] = path
+          end
+        end
+
         # @param obj [Object] Some user-returned value that may want to be batched
         # @param path [Array<String>]
         # @param field [GraphQL::Schema::Field]
@@ -420,16 +441,10 @@ module GraphQL
         # @param trace [Boolean] If `false`, don't wrap this with field tracing
         # @return [GraphQL::Execution::Lazy, Object] If loading `object` will be deferred, it's a wrapper over it.
         def after_lazy(lazy_obj, owner:, field:, path:, scoped_context:, owner_object:, arguments:, eager: false, trace: true, &block)
-          @interpreter_context[:current_object] = owner_object
-          @interpreter_context[:current_arguments] = arguments
-          @interpreter_context[:current_path] = path
-          @interpreter_context[:current_field] = field
+          set_all_interpreter_context(owner_object, field, arguments, path)
           if schema.lazy?(lazy_obj)
             lazy = GraphQL::Execution::Lazy.new(path: path, field: field) do
-              @interpreter_context[:current_path] = path
-              @interpreter_context[:current_field] = field
-              @interpreter_context[:current_object] = owner_object
-              @interpreter_context[:current_arguments] = arguments
+              set_all_interpreter_context(owner_object, field, arguments, path)
               context.scoped_context = scoped_context
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
@@ -540,6 +555,18 @@ module GraphQL
           res && res[:__dead]
         end
 
+        # Set this pair in the Query context, but also in the interpeter namespace,
+        # for compatibility.
+        def set_interpreter_context(key, value)
+          @interpreter_context[key] = value
+          @context[key] = value
+        end
+
+        def delete_interpreter_context(key)
+          @interpreter_context.delete(key)
+          @context.delete(key)
+        end
+
         def resolve_type(type, value, path)
           trace_payload = { context: context, type: type, object: value, path: path }
           resolved_type, resolved_value = query.trace("resolve_type", trace_payload) do