graphql 1.9.0.pre1 → 1.9.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8fec9f264c3f8ad38a18cb4f9f0b760341affe81
-  data.tar.gz: b64f5cf4561c22dd6fb45e60e3e1649c298cc461
+  metadata.gz: 7576d86b005acda0b6db32b531eb5ee5994b46d5
+  data.tar.gz: 5d27e5a79e0b2ab1d8c64edd8aa4ed5bc66b72e8
 SHA512:
-  metadata.gz: 7908c29710c195d11abe5111bcc66df3f573cc417f6b3360ef86b2ba96e7e14552981392c6e5d6e6f4237fb6ba6674d7300383a37f364e68080afebe4433f88f
-  data.tar.gz: cd1ebc2b2ebba1ee633de058e19e7954a971394989558ce5e7882d4206eef4db8668f939071cb3158eb7c896b2d6bd617ac98a852068a36143fd4c779f9afbe4
+  metadata.gz: 001ec87271eaefae504d24deac1c3b6d241f1b944b2297050e3d35a8a72c6a016ec9dd6a48f3c1bdef1ab5f9eb6aac2f5f31ca745bfdf9edb077abbc6f8158d7
+  data.tar.gz: fafac00586652e70e096f68a92dd20bcf712e09343d721638987f3ba8d69e77250fd25de5743ca521687c1a22a8df5355b4f7b84f500ff898446c29fe08e4bed

data/lib/graphql.rb

@@ -60,13 +60,15 @@ require "graphql/type_kinds"
 require "graphql/backwards_compatibility"
 require "graphql/scalar_type"
 
-require "graphql/directive"
 require "graphql/name_validator"
 
 require "graphql/language"
 require "graphql/analysis"
 require "graphql/tracing"
+require "graphql/execution"
+require "graphql/dig"
 require "graphql/schema"
+require "graphql/directive"
 require "graphql/execution"
 require "graphql/types"
 require "graphql/relay"
@@ -82,6 +84,7 @@ require "graphql/introspection"
 
 require "graphql/analysis_error"
 require "graphql/coercion_error"
+require "graphql/literal_validation_error"
 require "graphql/runtime_type_error"
 require "graphql/invalid_null_error"
 require "graphql/invalid_name_error"
@@ -101,3 +104,4 @@ require "graphql/backtrace"
 require "graphql/deprecated_dsl"
 require "graphql/authorization"
 require "graphql/unauthorized_error"
+require "graphql/unauthorized_field_error"

data/lib/graphql/analysis/ast/analyzer.rb

@@ -25,7 +25,7 @@ module GraphQL
           raise NotImplementedError
         end
 
-        # Don't use make_visit_method becuase it breaks `super`
+        # Don't use make_visit_method because it breaks `super`
         def self.build_visitor_hooks(member_name)
           class_eval(<<-EOS, __FILE__, __LINE__ + 1)
             def on_enter_#{member_name}(node, parent, visitor)

data/lib/graphql/analysis/ast/visitor.rb

@@ -81,7 +81,7 @@ module GraphQL
 
         def on_inline_fragment(node, parent)
           on_fragment_with_type(node) do
-            @path.push("...#{node.type ? " on #{node.type.to_query_string}" : ""}")
+            @path.push("...#{node.type ? " on #{node.type.name}" : ""}")
             call_analyzers(:on_enter_inline_fragment, node, parent)
             super
             call_analyzers(:on_leave_inline_fragment, node, parent)
@@ -203,6 +203,11 @@ module GraphQL
           @field_definitions.last
         end
 
+        # @return [GraphQL::Field, nil] The GraphQL field which returned the object that the current field belongs to
+        def previous_field_definition
+          @field_definitions[-2]
+        end
+
         # @return [GraphQL::Directive, nil] The most-recently-entered GraphQL::Directive, if currently inside one
         def directive_definition
           @directive_definitions.last

data/lib/graphql/backwards_compatibility.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module GraphQL
-  # Helpers for migrating in a backwards-compatibile way
+  # Helpers for migrating in a backwards-compatible way
   # @api private
   module BackwardsCompatibility
     module_function

data/lib/graphql/dig.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module GraphQL
+  module Dig
+    # implemented using the old activesupport #dig instead of the ruby built-in
+    # so we can use some of the magic in Schema::InputObject and Query::Arguments
+    # to handle stringified/symbolized keys.
+    #
+    # @param args [Array<[String, Symbol>] Retrieves the value object corresponding to the each key objects repeatedly
+    # @return [Object]
+    def dig(own_key, *rest_keys)
+      val = self[own_key]
+      if val.nil? || rest_keys.empty?
+        val
+      else
+        val.dig(*rest_keys)
+      end
+    end
+  end
+end

data/lib/graphql/directive.rb

@@ -14,7 +14,15 @@ module GraphQL
     attr_accessor :ast_node
     # @api private
     attr_writer :default_directive
-    ensure_defined(:locations, :arguments, :name, :description, :default_directive?)
+    ensure_defined(:locations, :arguments, :graphql_name, :name, :description, :default_directive?)
+
+    # Future-compatible alias
+    # @see {GraphQL::SchemaMember}
+    alias :graphql_name :name
+
+    # Future-compatible alias
+    # @see {GraphQL::SchemaMember}
+    alias :graphql_definition :itself
 
     LOCATIONS = [
       QUERY =                  :QUERY,
@@ -84,6 +92,10 @@ module GraphQL
     def default_directive?
       @default_directive
     end
+
+    def inspect
+      "#<GraphQL::Directive #{name}>"
+    end
   end
 end
 

data/lib/graphql/directive/include_directive.rb

@@ -1,8 +1,2 @@
 # frozen_string_literal: true
-GraphQL::Directive::IncludeDirective = GraphQL::Directive.define do
-  name "include"
-  description "Directs the executor to include this field or fragment only when the `if` argument is true."
-  locations([GraphQL::Directive::FIELD, GraphQL::Directive::FRAGMENT_SPREAD, GraphQL::Directive::INLINE_FRAGMENT])
-  argument :if, !GraphQL::BOOLEAN_TYPE, 'Included when true.'
-  default_directive true
-end
+GraphQL::Directive::IncludeDirective = GraphQL::Schema::Directive::Include.graphql_definition

data/lib/graphql/directive/skip_directive.rb

@@ -1,9 +1,2 @@
 # frozen_string_literal: true
-GraphQL::Directive::SkipDirective = GraphQL::Directive.define do
-  name "skip"
-  description "Directs the executor to skip this field or fragment when the `if` argument is true."
-  locations([GraphQL::Directive::FIELD, GraphQL::Directive::FRAGMENT_SPREAD, GraphQL::Directive::INLINE_FRAGMENT])
-
-  argument :if, !GraphQL::BOOLEAN_TYPE, 'Skipped when true.'
-  default_directive true
-end
+GraphQL::Directive::SkipDirective = GraphQL::Schema::Directive::Skip.graphql_definition

data/lib/graphql/execution/interpreter.rb

@@ -2,13 +2,12 @@
 require "graphql/execution/interpreter/execution_errors"
 require "graphql/execution/interpreter/hash_response"
 require "graphql/execution/interpreter/runtime"
+require "graphql/execution/interpreter/resolve"
 
 module GraphQL
   module Execution
     class Interpreter
       def initialize
-        # A buffer shared by all queries running in this interpreter
-        @lazies = []
       end
 
       # Support `Executor` :S
@@ -19,9 +18,16 @@ module GraphQL
       end
 
       def self.use(schema_defn)
-        schema_defn.query_execution_strategy(GraphQL::Execution::Interpreter)
-        schema_defn.mutation_execution_strategy(GraphQL::Execution::Interpreter)
-        schema_defn.subscription_execution_strategy(GraphQL::Execution::Interpreter)
+        schema_defn.target.interpreter = true
+        # Reach through the legacy objects for the actual class defn
+        schema_class = schema_defn.target.class
+        # This is not good, since both of these are holding state now,
+        # we have to update both :(
+        [schema_class, schema_defn].each do |schema_config|
+          schema_config.query_execution_strategy(GraphQL::Execution::Interpreter)
+          schema_config.mutation_execution_strategy(GraphQL::Execution::Interpreter)
+          schema_config.subscription_execution_strategy(GraphQL::Execution::Interpreter)
+        end
       end
 
       def self.begin_multiplex(multiplex)
@@ -51,14 +57,14 @@ module GraphQL
         }
       end
 
+      # Run the eager part of `query`
+      # @return {Interpreter::Runtime}
       def evaluate(query)
-        query.context.interpreter = true
         # Although queries in a multiplex _share_ an Interpreter instance,
         # they also have another item of state, which is private to that query
         # in particular, assign it here:
         runtime = Runtime.new(
           query: query,
-          lazies: @lazies,
           response: HashResponse.new,
         )
         query.context.namespace(:interpreter)[:runtime] = runtime
@@ -70,18 +76,22 @@ module GraphQL
         runtime
       end
 
+      # Run the lazy part of `query` or `multiplex`.
+      # @return [void]
       def sync_lazies(query: nil, multiplex: nil)
         tracer = query || multiplex
         if query.nil? && multiplex.queries.length == 1
           query = multiplex.queries[0]
         end
+        queries = multiplex ? multiplex.queries : [query]
+        final_values = queries.map do |query|
+          runtime = query.context.namespace(:interpreter)[:runtime]
+          # it might not be present if the query has an error
+          runtime ? runtime.final_value : nil
+        end
+        final_values.compact!
         tracer.trace("execute_query_lazy", {multiplex: multiplex, query: query}) do
-          while @lazies.any?
-            next_wave = @lazies.dup
-            @lazies.clear
-            # This will cause a side-effect with `.write(...)`
-            next_wave.each(&:value)
-          end
+          Interpreter::Resolve.resolve_all(final_values)
         end
       end
     end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      module Resolve
+        def self.resolve_all(results)
+          while results.any?
+            results = resolve(results)
+          end
+        end
+
+        # After getting `results` back from an interpreter evaluation,
+        # continue it until you get a response-ready Ruby value.
+        #
+        # `results` is one level of _depth_ of a query or multiplex.
+        #
+        # Resolve all lazy values in that depth before moving on
+        # to the next level.
+        #
+        # It's assumed that the lazies will
+        # return {Lazy} instances if there's more work to be done,
+        # or return {Hash}/{Array} if the query should be continued.
+        #
+        # @param results [Array]
+        # @return [Array] Same size, filled with finished values
+        def self.resolve(results)
+          next_results = []
+
+          # Work through the queue until it's empty
+          while results.size > 0
+            result_value = results.shift
+
+            if result_value.is_a?(Lazy)
+              result_value = result_value.value
+            end
+
+            if result_value.is_a?(Lazy)
+              # Since this field returned another lazy,
+              # add it to the same queue
+              results << result_value
+            elsif result_value.is_a?(Hash)
+              # This is part of the next level, add it
+              next_results.concat(result_value.values)
+            elsif result_value.is_a?(Array)
+              # This is part of the next level, add it
+              next_results.concat(result_value)
+            end
+          end
+
+          next_results
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,8 @@ module GraphQL
     class Interpreter
       # I think it would be even better if we could somehow make
       # `continue_field` not recursive. "Trampolining" it somehow.
+      #
+      # @api private
       class Runtime
         # @return [GraphQL::Query]
         attr_reader :query
@@ -15,14 +17,18 @@ module GraphQL
         # @return [GraphQL::Query::Context]
         attr_reader :context
 
-        def initialize(query:, lazies:, response:)
+        def initialize(query:, response:)
           @query = query
           @schema = query.schema
           @context = query.context
-          @lazies = lazies
+          @interpreter_context = @context.namespace(:interpreter)
           @response = response
           @dead_paths = {}
           @types_at_paths = {}
+          # A cache of { Class => { String => Schema::Field } }
+          # Which assumes that MyObject.get_field("myField") will return the same field
+          # during the lifetime of a query
+          @fields_cache = Hash.new { |h, k| h[k] = {} }
         end
 
         def final_value
@@ -34,7 +40,7 @@ module GraphQL
         end
 
         # This _begins_ the execution. Some deferred work
-        # might be stored up in {@lazies}.
+        # might be stored up in lazies.
         # @return [void]
         def run_eager
           root_operation = query.selected_operation
@@ -42,44 +48,59 @@ module GraphQL
           legacy_root_type = schema.root_type_for_operation(root_op_type)
           root_type = legacy_root_type.metadata[:type_class] || raise("Invariant: type must be class-based: #{legacy_root_type}")
           object_proxy = root_type.authorized_new(query.root_value, context)
-
+          object_proxy = schema.sync_lazy(object_proxy)
           path = []
           evaluate_selections(path, object_proxy, root_type, root_operation.selections, root_operation_type: root_op_type)
+          nil
         end
 
-        private
-
-        def gather_selections(owner_type, selections, selections_by_name)
+        def gather_selections(owner_object, owner_type, selections, selections_by_name)
           selections.each do |node|
+            # Skip gathering this if the directive says so
+            if !directives_include?(node, owner_object, owner_type)
+              next
+            end
+
             case node
             when GraphQL::Language::Nodes::Field
-              if passes_skip_and_include?(node)
-                response_key = node.alias || node.name
-                s = selections_by_name[response_key] ||= []
+              response_key = node.alias || node.name
+              selections = selections_by_name[response_key]
+              # if there was already a selection of this field,
+              # use an array to hold all selections,
+              # otherise, use the single node to represent the selection
+              if selections
+                # This field was already selected at least once,
+                # add this node to the list of selections
+                s = Array(selections)
                 s << node
+                selections_by_name[response_key] = s
+              else
+                # No selection was found for this field yet
+                selections_by_name[response_key] = node
               end
             when GraphQL::Language::Nodes::InlineFragment
-              if passes_skip_and_include?(node)
-                include_fragmment = if node.type
-                  type_defn = schema.types[node.type.name]
-                  type_defn = type_defn.metadata[:type_class]
-                  possible_types = query.warden.possible_types(type_defn).map { |t| t.metadata[:type_class] }
-                  possible_types.include?(owner_type)
-                else
-                  true
-                end
-                if include_fragmment
-                  gather_selections(owner_type, node.selections, selections_by_name)
+              if node.type
+                type_defn = schema.types[node.type.name]
+                type_defn = type_defn.metadata[:type_class]
+                # Faster than .map{}.include?()
+                query.warden.possible_types(type_defn).each do |t|
+                  if t.metadata[:type_class] == owner_type
+                    gather_selections(owner_object, owner_type, node.selections, selections_by_name)
+                    break
+                  end
                 end
+              else
+                # it's an untyped fragment, definitely continue
+                gather_selections(owner_object, owner_type, node.selections, selections_by_name)
               end
             when GraphQL::Language::Nodes::FragmentSpread
-              if passes_skip_and_include?(node)
-                fragment_def = query.fragments[node.name]
-                type_defn = schema.types[fragment_def.type.name]
-                type_defn = type_defn.metadata[:type_class]
-                possible_types = schema.possible_types(type_defn).map { |t| t.metadata[:type_class] }
-                if possible_types.include?(owner_type)
-                  gather_selections(owner_type, fragment_def.selections, selections_by_name)
+              fragment_def = query.fragments[node.name]
+              type_defn = schema.types[fragment_def.type.name]
+              type_defn = type_defn.metadata[:type_class]
+              schema.possible_types(type_defn).each do |t|
+                if t.metadata[:type_class] == owner_type
+                  gather_selections(owner_object, owner_type, fragment_def.selections, selections_by_name)
+                  break
                 end
               end
             else
@@ -90,11 +111,20 @@ module GraphQL
 
         def evaluate_selections(path, owner_object, owner_type, selections, root_operation_type: nil)
           selections_by_name = {}
-          gather_selections(owner_type, selections, selections_by_name)
-          selections_by_name.each do |result_name, fields|
-            ast_node = fields.first
+          gather_selections(owner_object, owner_type, selections, selections_by_name)
+          selections_by_name.each do |result_name, field_ast_nodes_or_ast_node|
+            # As a performance optimization, the hash key will be a `Node` if
+            # there's only one selection of the field. But if there are multiple
+            # selections of the field, it will be an Array of nodes
+            if field_ast_nodes_or_ast_node.is_a?(Array)
+              field_ast_nodes = field_ast_nodes_or_ast_node
+              ast_node = field_ast_nodes.first
+            else
+              field_ast_nodes = nil
+              ast_node = field_ast_nodes_or_ast_node
+            end
             field_name = ast_node.name
-            field_defn = owner_type.get_field(field_name)
+            field_defn = @fields_cache[owner_type][field_name] ||= owner_type.get_field(field_name)
             is_introspection = false
             if field_defn.nil?
               field_defn = if owner_type == schema.query.metadata[:type_class] && (entry_point_field = schema.introspection_system.entry_point(name: field_name))
@@ -118,6 +148,9 @@ module GraphQL
             # the field's return type at this path in order
             # 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
 
             object = owner_object
 
@@ -125,6 +158,7 @@ module GraphQL
               object = field_defn.owner.authorized_new(object, context)
             end
 
+
             kwarg_arguments = arguments(object, field_defn, ast_node)
             # It might turn out that making arguments for every field is slow.
             # If we have to cache them, we'll need a more subtle approach here.
@@ -136,30 +170,47 @@ module GraphQL
                 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,
+                )
               else
                 kwarg_arguments[extra] = field_defn.fetch_extra(extra, context)
               end
             end
 
-            next_selections = fields.inject([]) { |memo, f| memo.concat(f.selections) }
-
-            app_result = query.trace("execute_field", {field: field_defn, path: next_path}) do
-              field_defn.resolve(object, kwarg_arguments, context)
+            # Optimize for the case that field is selected only once
+            if field_ast_nodes.nil? || field_ast_nodes.size == 1
+              next_selections = ast_node.selections
+            else
+              next_selections = []
+              field_ast_nodes.each { |f| next_selections.concat(f.selections) }
             end
 
-            after_lazy(app_result, field: field_defn, path: next_path, eager: root_operation_type == "mutation") do |inner_result|
-              continue_value = continue_value(next_path, inner_result, field_defn, return_type, ast_node)
-              if HALT != continue_value
-                continue_field(next_path, continue_value, field_defn, return_type, ast_node, next_selections)
+            resolve_with_directives(object, ast_node) do
+              # Actually call the field resolver and capture the result
+              app_result = query.trace("execute_field", {field: field_defn, path: next_path}) do
+                field_defn.resolve(object, kwarg_arguments, context)
+              end
+              after_lazy(app_result, field: field_defn, path: next_path, eager: root_operation_type == "mutation") do |inner_result|
+                continue_value = continue_value(next_path, inner_result, field_defn, return_type.non_null?, ast_node)
+                if HALT != continue_value
+                  continue_field(next_path, continue_value, field_defn, return_type, ast_node, next_selections, false)
+                end
               end
             end
           end
         end
 
         HALT = Object.new
-        def continue_value(path, value, field, as_type, ast_node)
+        def continue_value(path, value, field, is_non_null, ast_node)
           if value.nil?
-            if as_type.non_null?
+            if is_non_null
               err = GraphQL::InvalidNullError.new(field.owner, field, value)
               write_invalid_null_in_response(path, err)
             else
@@ -187,7 +238,7 @@ module GraphQL
               err
             end
 
-            continue_value(path, next_value, field, as_type, ast_node)
+            continue_value(path, next_value, field, is_non_null, ast_node)
           elsif GraphQL::Execution::Execute::SKIP == value
             HALT
           else
@@ -195,11 +246,20 @@ module GraphQL
           end
         end
 
-        def continue_field(path, value, field, type, ast_node, next_selections)
+        # The resolver for `field` returned `value`. Continue to execute the query,
+        # treating `value` as `type` (probably the return type of the field).
+        #
+        # Use `next_selections` to resolve object fields, if there are any.
+        #
+        # 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)
           case type.kind.name
           when "SCALAR", "ENUM"
             r = type.coerce_result(value, context)
             write_in_response(path, r)
+            r
           when "UNION", "INTERFACE"
             resolved_type = query.resolve_type(type, value)
             possible_types = query.possible_types(type)
@@ -209,9 +269,10 @@ module GraphQL
               type_error = GraphQL::UnresolvedTypeError.new(value, field, parent_type, resolved_type, possible_types)
               schema.type_error(type_error, context)
               write_in_response(path, nil)
+              nil
             else
               resolved_type = resolved_type.metadata[:type_class]
-              continue_field(path, value, field, resolved_type, ast_node, next_selections)
+              continue_field(path, value, field, resolved_type, ast_node, next_selections, is_non_null)
             end
           when "OBJECT"
             object_proxy = begin
@@ -220,49 +281,73 @@ module GraphQL
               err
             end
             after_lazy(object_proxy, path: path, field: field) do |inner_object|
-              continue_value = continue_value(path, inner_object, field, type, ast_node)
+              continue_value = continue_value(path, inner_object, field, is_non_null, ast_node)
               if HALT != continue_value
-                write_in_response(path, {})
+                response_hash = {}
+                write_in_response(path, response_hash)
                 evaluate_selections(path, continue_value, type, next_selections)
+                response_hash
               end
             end
           when "LIST"
-            write_in_response(path, [])
+            response_list = []
+            write_in_response(path, response_list)
             inner_type = type.of_type
             idx = 0
             value.each do |inner_value|
               next_path = path.dup
               next_path << idx
               next_path.freeze
+              idx += 1
               set_type_at_path(next_path, inner_type)
+              # This will update `response_list` with the lazy
               after_lazy(inner_value, path: next_path, field: field) do |inner_inner_value|
-                continue_value = continue_value(next_path, inner_inner_value, field, inner_type, ast_node)
+                # reset `is_non_null` here and below, because the inner type will have its own nullability constraint
+                continue_value = continue_value(next_path, inner_inner_value, field, false, ast_node)
                 if HALT != continue_value
-                  continue_field(next_path, continue_value, field, inner_type, ast_node, next_selections)
+                  continue_field(next_path, continue_value, field, inner_type, ast_node, next_selections, false)
                 end
               end
-              idx += 1
             end
+            response_list
           when "NON_NULL"
             inner_type = type.of_type
             # For fields like `__schema: __Schema!`
             inner_type = resolve_if_late_bound_type(inner_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)
+            continue_field(path, value, field, inner_type, ast_node, next_selections, true)
           else
             raise "Invariant: Unhandled type kind #{type.kind} (#{type})"
           end
         end
 
-        def passes_skip_and_include?(node)
-          # Eventually this should actually call out to the directives
-          # instead of having magical hard-coded behavior.
-          node.directives.each do |dir|
-            dir_defn = schema.directives.fetch(dir.name)
-            if dir.name == "skip" && arguments(nil, dir_defn, dir)[:if] == true
-              return false
-            elsif dir.name == "include" && arguments(nil, dir_defn, dir)[:if] == false
+        def resolve_with_directives(object, ast_node)
+          run_directive(object, ast_node, 0) { yield }
+        end
+
+        def run_directive(object, ast_node, idx)
+          dir_node = ast_node.directives[idx]
+          if !dir_node
+            yield
+          else
+            dir_defn = schema.directives.fetch(dir_node.name)
+            if !dir_defn.is_a?(Class)
+              dir_defn = dir_defn.metadata[:type_class] || raise("Only class-based directives are supported (not `@#{dir_node.name}`)")
+            end
+            dir_args = arguments(nil, dir_defn, dir_node)
+            dir_defn.resolve(object, dir_args, context) do
+              run_directive(object, ast_node, idx + 1) { yield }
+            end
+          end
+        end
+
+        # Check {Schema::Directive.include?} for each directive that's present
+        def directives_include?(node, graphql_object, parent_type)
+          node.directives.each do |dir_node|
+            dir_defn = schema.directives.fetch(dir_node.name).metadata[:type_class] || raise("Only class-based directives are supported (not #{dir_node.name.inspect})")
+            args = arguments(graphql_object, dir_defn, dir_node)
+            if !dir_defn.include?(graphql_object, args, context)
               return false
             end
           end
@@ -283,8 +368,12 @@ module GraphQL
         # @param eager [Boolean] Set to `true` for mutation root fields only
         # @return [GraphQL::Execution::Lazy, Object] If loading `object` will be deferred, it's a wrapper over it.
         def after_lazy(obj, field:, path:, eager: false)
+          @interpreter_context[:current_path] = path
+          @interpreter_context[:current_field] = field
           if schema.lazy?(obj)
-            lazy = GraphQL::Execution::Lazy.new do
+            lazy = GraphQL::Execution::Lazy.new(path: path, field: field) do
+              @interpreter_context[:current_path] = path
+              @interpreter_context[:current_field] = field
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
               inner_obj = query.trace("execute_field_lazy", {field: field, path: path}) do
@@ -302,21 +391,38 @@ module GraphQL
             if eager
               lazy.value
             else
-              @lazies << lazy
+              write_in_response(path, lazy)
+              lazy
             end
           else
             yield(obj)
           end
         end
 
-        def arguments(graphql_object, arg_owner, ast_node)
+        def each_argument_pair(ast_args_or_hash)
+          case ast_args_or_hash
+          when GraphQL::Language::Nodes::Field, GraphQL::Language::Nodes::InputObject, GraphQL::Language::Nodes::Directive
+            ast_args_or_hash.arguments.each do |arg|
+              yield(arg.name, arg.value)
+            end
+          when Hash
+            ast_args_or_hash.each do |key, value|
+              normalized_name = GraphQL::Schema::Member::BuildType.camelize(key.to_s)
+              yield(normalized_name, value)
+            end
+          else
+            raise "Invariant, unexpected #{ast_args_or_hash.inspect}"
+          end
+        end
+
+        def arguments(graphql_object, arg_owner, ast_node_or_hash)
           kwarg_arguments = {}
           arg_defns = arg_owner.arguments
-          ast_node.arguments.each do |arg|
-            arg_defn = arg_defns[arg.name]
+          each_argument_pair(ast_node_or_hash) do |arg_name, arg_value|
+            arg_defn = arg_defns[arg_name]
             # Need to distinguish between client-provided `nil`
             # and nothing-at-all
-            is_present, value = arg_to_value(graphql_object, arg_defn.type, arg.value)
+            is_present, value = arg_to_value(graphql_object, arg_defn.type, arg_value)
             if is_present
               # This doesn't apply to directives, which are legacy
               # Can remove this when Skip and Include use classes or something.
@@ -328,7 +434,8 @@ module GraphQL
           end
           arg_defns.each do |name, arg_defn|
             if arg_defn.default_value? && !kwarg_arguments.key?(arg_defn.keyword)
-              kwarg_arguments[arg_defn.keyword] = arg_defn.default_value
+              _is_present, value = arg_to_value(graphql_object, arg_defn.type, arg_defn.default_value)
+              kwarg_arguments[arg_defn.keyword] = value
             end
           end
           kwarg_arguments
@@ -432,9 +539,6 @@ module GraphQL
         def type_at(path)
           t = @types_at_paths
           path.each do |part|
-            if part.is_a?(Integer)
-              part = 0
-            end
             t = t[part] || (raise("Invariant: #{part.inspect} not found in #{t}"))
           end
           t = t[:__type]
@@ -444,10 +548,6 @@ module GraphQL
         def set_type_at_path(path, type)
           types = @types_at_paths
           path.each do |part|
-            if part.is_a?(Integer)
-              part = 0
-            end
-
             types = types[part] ||= {}
           end
           # Use this magic key so that the hash contains: