graphql 1.11.1 → 1.11.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b152fd76301d994c8a685bce0539e409739c6e1e303c611c34a6424b2d2e68e
-  data.tar.gz: 84215fce3790161bebfa183e05b69abe6394396bec177ce69f98e5a53484d7b5
+  metadata.gz: 1b6e1d6fb5063c843becb61784cb776964a380af5a2fc5a98054d2554ddf4caa
+  data.tar.gz: c41027cdf69f8c07bed157075c70e95936f3d26922f0b1d38f7759352a35ab43
 SHA512:
-  metadata.gz: 83d130c2cd4c76f9869d60e4a32f80e2a20a3ff5c614e6852686c1d06d2da8b454065b5c382099877c2449e77f938f8ef5e2dfd69e22bf5a505e04a3edb8db2d
-  data.tar.gz: 06bf9038ca1f32d03fc4a0fc2ed6763420ff58d7c7b4aaad38a703b0eb090c3a35fb829c2a7e13420c1507ea8013e5d7084067c733de98b416698ea39ba46ba3
+  metadata.gz: 3dc4e13b30d51c32775785b9ed4a11940bc2cb541866877e6eef48bc621956700ddf057c597d2bc5a9fa09ca863e01ba84295e414e488e22ee03b94c28bc4003
+  data.tar.gz: 70f5ba8c04e13b83af431db1e8edea297a3c43acc6f6356668094349b577fe7de4e8cdb029aaf8ce70cc243664915ac7dac38612badd0acb720ce57464769cec

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/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,
@@ -5,7 +6,7 @@ class GraphqlController < ApplicationController
   # protect_from_forgery with: :null_session
 
   def execute
-    variables = ensure_hash(params[:variables])
+    variables = prepare_variables(params[:variables])
     query = params[:query]
     operation_name = params[:operationName]
     context = {
@@ -21,21 +22,23 @@ class GraphqlController < ApplicationController
 
   private
 
-  # Handle form data, JSON body, or a blank value
-  def ensure_hash(ambiguous_param)
-    case ambiguous_param
+  # Handle variables in form data, JSON body, or a blank value
+  def prepare_variables(variables_param)
+    case variables_param
     when String
-      if ambiguous_param.present?
-        ensure_hash(JSON.parse(ambiguous_param))
+      if variables_param.present?
+        JSON.parse(variables_param) || {}
       else
         {}
       end
-    when Hash, ActionController::Parameters
-      ambiguous_param
+    when Hash
+      variables_param
+    when ActionController::Parameters
+      variables_param.to_unsafe_hash # GraphQL-Ruby will validate name and type of incoming variables.
     when nil
       {}
     else
-      raise ArgumentError, "Unexpected parameter: #{ambiguous_param}"
+      raise ArgumentError, "Unexpected parameter: #{variables_param}"
     end
   end
 
@@ -46,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:

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/directive.rb

@@ -99,6 +99,10 @@ module GraphQL
     def type_class
       metadata[:type_class]
     end
+
+    def get_argument(argument_name)
+      arguments[argument_name]
+    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

@@ -24,7 +24,7 @@ module GraphQL
         # @return [Hash{Symbol => ArgumentValue}]
         attr_reader :argument_values
 
-        def_delegators :@keyword_arguments, :key?, :[], :keys, :each, :values
+        def_delegators :@keyword_arguments, :key?, :[], :fetch, :keys, :each, :values
         def_delegators :@argument_values, :each_value
 
         def inspect

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

@@ -43,23 +43,25 @@ 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_interpreter_context(:current_object, query.root_value)
+          set_interpreter_context(:current_path, 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)
@@ -117,8 +119,8 @@ module GraphQL
         end
 
         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_interpreter_context(:current_object, owner_object)
+          set_interpreter_context(:current_path, 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,8 @@ 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_interpreter_context(:current_path, next_path)
+            set_interpreter_context(:current_field, field_defn)
 
             context.scoped_context = scoped_context
             object = owner_object
@@ -170,13 +172,13 @@ 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)
+              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)
+                continue_value(next_path, resolved_arguments, owner_type, field_defn, return_type.non_null?, ast_node)
                 next
               end
 
@@ -206,7 +208,7 @@ module GraphQL
                 end
               end
 
-              @interpreter_context[:current_arguments] = kwarg_arguments
+              set_interpreter_context(:current_arguments, kwarg_arguments)
 
               # Optimize for the case that field is selected only once
               if field_ast_nodes.nil? || field_ast_nodes.size == 1
@@ -228,12 +230,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 +253,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 +283,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 +299,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 +353,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 +372,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
 
@@ -420,16 +421,16 @@ 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_interpreter_context(:current_object, owner_object)
+          set_interpreter_context(:current_arguments, arguments)
+          set_interpreter_context(:current_path, path)
+          set_interpreter_context(:current_field, field)
           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_interpreter_context(:current_path, path)
+              set_interpreter_context(:current_field, field)
+              set_interpreter_context(:current_object, owner_object)
+              set_interpreter_context(:current_arguments, arguments)
               context.scoped_context = scoped_context
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
@@ -461,8 +462,9 @@ module GraphQL
         end
 
         def arguments(graphql_object, arg_owner, ast_node)
-          # Don't cache arguments if field extras are requested since extras mutate the argument data structure
-          if arg_owner.arguments_statically_coercible? && (!arg_owner.is_a?(GraphQL::Schema::Field) || arg_owner.extras.empty?)
+          # Don't cache arguments if field extras or extensions are requested since they can mutate the argument data structure
+          if arg_owner.arguments_statically_coercible? &&
+              (!arg_owner.is_a?(GraphQL::Schema::Field) || (arg_owner.extras.empty? && arg_owner.extensions.empty?))
             query.arguments_for(ast_node, arg_owner)
           else
             # The arguments must be prepared in the context of the given object
@@ -539,6 +541,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