graphql 1.12.18 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d1cfa93dc97adf13e461a45a00899f5ecc3e27d66c54c33d1a319b027665b78
-  data.tar.gz: 5d8cf2b669619dd15058400e15342ff225ba02716c5d8c9959c74260d4f51b32
+  metadata.gz: 853fa0482ef0c3bafe04dce77dff9bb685633a1e4c273fd234169f98d595352c
+  data.tar.gz: 6cf800af8dfc469f4d7a375ee22f6d98e03207799f813f10176916f09a0a4064
 SHA512:
-  metadata.gz: d7ff04a88e0ae883c382aa6559b52c38dbbc7d513537aaf506e89dd7880c227b6b032f7329c1c9e7b0fb9692b3e0e6fdbaac9df9fc82e536fb1e12b9cff2f65c
-  data.tar.gz: 3276674be3f8b0eb05d5c8904cad3ef20697bf5b9efcb133bd7c283d7bd704d52cd75f87a46f6c1fd988faf6c439c796d186280f4e397f8dc5184ae7d17c333b
+  metadata.gz: 7bcd2b94fa64ab65fb47995a4896b08629bfc9b66f7797dfd4959ad8ccdb5332bf63ae49f5139c7d1766b3d72cb500da257c611e628dc5db36ae26b472c5d51c
+  data.tar.gz: 51a5c6791429c17940d8d0a5407efb852fd4ddbe7a5eaf706dd8fb074a6654f17b32b08f21956e4e450dff6cff05fb0020a7ff8a141fe38f3e09b8433ca1b4ea

data/lib/generators/graphql/mutation_generator.rb

@@ -17,7 +17,7 @@ module Graphql
 
       argument :name, type: :string
 
-      def initialize(args, *options) #:nodoc:
+      def initialize(args, *options) # :nodoc:
         # Unfreeze name in case it's given as a frozen string
         args[0] = args[0].dup if args[0].is_a?(String) && args[0].frozen?
         super

data/lib/generators/graphql/object_generator.rb

@@ -12,7 +12,8 @@ module Graphql
     #
     # Add the Node interface with `--node`.
     class ObjectGenerator < TypeGeneratorBase
-      desc "Create a GraphQL::ObjectType with the given name and fields"
+      desc "Create a GraphQL::ObjectType with the given name and fields." \
+      "If the given type name matches an existing ActiveRecord model, the generated type will automatically include fields for the models database columns."
       source_root File.expand_path('../templates', __FILE__)
 
       argument :custom_fields,

data/lib/generators/graphql/relay.rb

@@ -32,20 +32,28 @@ module Graphql
 
   # Return a string UUID for `object`
   def self.id_from_object(object, type_definition, query_ctx)
-    # Here's a simple implementation which:
-    # - joins the type name & object.id
-    # - encodes it with base64:
-    # GraphQL::Schema::UniqueWithinType.encode(type_definition.name, object.id)
+    # For example, use Rails' GlobalID library (https://github.com/rails/globalid):
+    object_id = object.to_global_id.to_s
+    # Remove this redundant prefix to make IDs shorter:
+    object_id = object_id.sub("gid://\#{GlobalID.app}/", "")
+    encoded_id = Base64.urlsafe_encode64(object_id)
+    # Remove the "=" padding
+    encoded_id = encoded_id.sub(/=+/, "")
+    # Add a type hint
+    type_hint = type_definition.graphql_name.first
+    "\#{type_hint}_\#{encoded_id}"
   end
 
   # Given a string UUID, find the object
-  def self.object_from_id(id, query_ctx)
-    # For example, to decode the UUIDs generated above:
-    # type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(id)
-    #
-    # Then, based on `type_name` and `id`
-    # find an object in your application
-    # ...
+  def self.object_from_id(encoded_id_with_hint, query_ctx)
+    # For example, use Rails' GlobalID library (https://github.com/rails/globalid):
+    # Split off the type hint
+    _type_hint, encoded_id = encoded_id_with_hint.split("_", 2)
+    # Decode the ID
+    id = Base64.urlsafe_decode64(encoded_id)
+    # Rebuild it for Rails then find the object:
+    full_global_id = "gid://\#{GlobalID.app}/\#{id}"
+    GlobalID::Locator.locate(full_global_id)
   end
 RUBY
         inject_into_file schema_file_path, schema_code, before: /^end\n/m, force: false

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

@@ -4,11 +4,23 @@ class <%= schema_name %> < GraphQL::Schema
 <% if options[:batch] %>
   # GraphQL::Batch setup:
   use GraphQL::Batch
+<% else %>
+  # For batch-loading (see https://graphql-ruby.org/dataloader/overview.html)
+  use GraphQL::Dataloader
 <% end %>
+  # GraphQL-Ruby calls this when something goes wrong while running a query:
+  def self.type_error(err, context)
+    # if err.is_a?(GraphQL::InvalidNullError)
+    #   # report to your bug tracker here
+    #   return nil
+    # end
+    super
+  end
+
   # Union and Interface Resolution
   def self.resolve_type(abstract_type, obj, ctx)
-    # TODO: Implement this function
-    # to return the correct object type for `obj`
+    # TODO: Implement this method
+    # to return the correct GraphQL object type for `obj`
     raise(GraphQL::RequiredImplementationMissingError)
   end
 end

data/lib/generators/graphql/type_generator.rb

@@ -13,7 +13,6 @@ module Graphql
 
       argument :type_name,
         type: :string,
-        required: true,
         banner: "TypeName",
         desc: "Name of this object type (expressed as Ruby or GraphQL)"
 

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

@@ -36,12 +36,12 @@ module GraphQL
             end
 
             if argument.definition.type.kind.input_object?
-              extract_deprecated_arguments(argument.value.arguments.argument_values)
+              extract_deprecated_arguments(argument.value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
             elsif argument.definition.type.list? && !argument.value.nil?
               argument
                 .value
                 .select { |value| value.respond_to?(:arguments) }
-                .each { |value| extract_deprecated_arguments(value.arguments.argument_values) }
+                .each { |value| extract_deprecated_arguments(value.arguments.argument_values) } # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
             end
           end
         end

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

@@ -23,18 +23,22 @@ module GraphQL
 
           attr_reader :field_definition, :response_path, :query
 
-          # @param node [Language::Nodes::Field] The AST node; used for providing argument values when necessary
+          # @param parent_type [Class] The owner of `field_definition`
           # @param field_definition [GraphQL::Field, GraphQL::Schema::Field] Used for getting the `.complexity` configuration
           # @param query [GraphQL::Query] Used for `query.possible_types`
           # @param response_path [Array<String>] The path to the response key for the field
-          def initialize(node, field_definition, query, response_path)
-            @node = node
+          def initialize(parent_type, field_definition, query, response_path)
+            @parent_type = parent_type
             @field_definition = field_definition
             @query = query
             @response_path = response_path
             @scoped_children = nil
+            @nodes = []
           end
 
+          # @return [Array<GraphQL::Language::Nodes::Field>]
+          attr_reader :nodes
+
           # Returns true if this field has no selections, ie, it's a scalar.
           # We need a quick way to check whether we should continue traversing.
           def terminal?
@@ -50,16 +54,7 @@ module GraphQL
           end
 
           def own_complexity(child_complexity)
-            defined_complexity = @field_definition.complexity
-            case defined_complexity
-            when Proc
-              arguments = @query.arguments_for(@node, @field_definition)
-              defined_complexity.call(@query.context, arguments.keyword_arguments, child_complexity)
-            when Numeric
-              defined_complexity + child_complexity
-            else
-              raise("Invalid complexity: #{defined_complexity.inspect} on #{@field_definition.name}")
-            end
+            @field_definition.calculate_complexity(query: @query, nodes: @nodes, child_complexity: child_complexity)
           end
         end
 
@@ -79,7 +74,8 @@ module GraphQL
           # then the query would have been rejected as invalid.
           complexities_on_type = @complexities_on_type_by_query[visitor.query] ||= [ScopedTypeComplexity.new(nil, nil, query, visitor.response_path)]
 
-          complexity = complexities_on_type.last.scoped_children[parent_type][field_key] ||= ScopedTypeComplexity.new(node, visitor.field_definition, visitor.query, visitor.response_path)
+          complexity = complexities_on_type.last.scoped_children[parent_type][field_key] ||= ScopedTypeComplexity.new(parent_type, visitor.field_definition, visitor.query, visitor.response_path)
+          complexity.nodes.push(node)
           # Push it on the stack.
           complexities_on_type.push(complexity)
         end

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

@@ -100,7 +100,7 @@ module GraphQL
         def on_field(node, parent)
           @response_path.push(node.alias || node.name)
           parent_type = @object_types.last
-          field_definition = @schema.get_field(parent_type, node.name)
+          field_definition = @schema.get_field(parent_type, node.name, @query.context)
           @field_definitions.push(field_definition)
           if !field_definition.nil?
             next_object_type = field_definition.type.unwrap
@@ -138,14 +138,14 @@ module GraphQL
           argument_defn = if (arg = @argument_definitions.last)
             arg_type = arg.type.unwrap
             if arg_type.kind.input_object?
-              arg_type.arguments[node.name]
+              arg_type.get_argument(node.name, @query.context)
             else
               nil
             end
           elsif (directive_defn = @directive_definitions.last)
-            directive_defn.arguments[node.name]
+            directive_defn.get_argument(node.name, @query.context)
           elsif (field_defn = @field_definitions.last)
-            field_defn.arguments[node.name]
+            field_defn.get_argument(node.name, @query.context)
           else
             nil
           end

data/lib/graphql/backtrace/table.rb

@@ -89,7 +89,7 @@ module GraphQL
             "#{context_entry.ast_node ? context_entry.ast_node.position.join(":") : ""}",
             "#{context_entry.field.path}#{field_alias ? " as #{field_alias}" : ""}",
             "#{context_entry.object.object.inspect}",
-            context_entry.arguments.to_h.inspect,
+            context_entry.arguments.to_h.inspect, # rubocop:disable Development/ContextIsPassedCop -- unrelated method
             Backtrace::InspectResult.inspect_result(value),
           ]
           if (parent = context_entry.parent_frame)

data/lib/graphql/dataloader/source.rb

@@ -6,7 +6,11 @@ module GraphQL
       # Called by {Dataloader} to prepare the {Source}'s internal state
       # @api private
       def setup(dataloader)
+        # These keys have been requested but haven't been fetched yet
         @pending_keys = []
+        # These keys have been passed to `fetch` but haven't been finished yet
+        @fetching_keys = []
+        # { key => result }
         @results = {}
         @dataloader = dataloader
       end
@@ -64,29 +68,46 @@ module GraphQL
       # Then run the batch and update the cache.
       # @return [void]
       def sync
+        pending_keys = @pending_keys.dup
         @dataloader.yield
+        iterations = 0
+        while pending_keys.any? { |k| !@results.key?(k) }
+          iterations += 1
+          if iterations > 1000
+            raise "#{self.class}#sync tried 1000 times to load pending keys (#{pending_keys}), but they still weren't loaded. There is likely a circular dependency."
+          end
+          @dataloader.yield
+        end
+        nil
       end
 
       # @return [Boolean] True if this source has any pending requests for data.
       def pending?
-        @pending_keys.any?
+        !@pending_keys.empty?
       end
 
       # Called by {GraphQL::Dataloader} to resolve and pending requests to this source.
       # @api private
       # @return [void]
       def run_pending_keys
+        if !@fetching_keys.empty?
+          @pending_keys -= @fetching_keys
+        end
         return if @pending_keys.empty?
         fetch_keys = @pending_keys.uniq
+        @fetching_keys.concat(fetch_keys)
         @pending_keys = []
         results = fetch(fetch_keys)
         fetch_keys.each_with_index do |key, idx|
           @results[key] = results[idx]
         end
+        nil
       rescue StandardError => error
         fetch_keys.each { |key| @results[key] = error }
       ensure
-        nil
+        if fetch_keys
+          @fetching_keys -= fetch_keys
+        end
       end
 
       # These arguments are given to `dataloader.with(source_class, ...)`. The object
@@ -116,6 +137,13 @@ module GraphQL
       # @return [Object] The result from {#fetch} for `key`.
       # @api private
       def result_for(key)
+        if !@results.key?(key)
+          raise <<-ERR
+Invariant: fetching result for a key on #{self.class} that hasn't been loaded yet (#{key.inspect}, loaded: #{@results.keys})
+
+This key should have been loaded already. This is a bug in GraphQL::Dataloader, please report it on GitHub: https://github.com/rmosolgo/graphql-ruby/issues/new.
+ERR
+        end
         result = @results[key]
 
         raise result if result.class <= StandardError

data/lib/graphql/dataloader.rb

@@ -23,8 +23,18 @@ module GraphQL
   #   end
   #
   class Dataloader
-    def self.use(schema)
-      schema.dataloader_class = self
+    class << self
+      attr_accessor :default_nonblocking
+    end
+
+    AsyncDataloader = Class.new(self) { self.default_nonblocking = true }
+
+    def self.use(schema, nonblocking: nil)
+      schema.dataloader_class = if nonblocking
+        AsyncDataloader
+      else
+        self
+      end
     end
 
     # Call the block with a Dataloader instance,
@@ -39,9 +49,16 @@ module GraphQL
       result
     end
 
-    def initialize
+    def initialize(nonblocking: self.class.default_nonblocking)
       @source_cache = Hash.new { |h, k| h[k] = {} }
       @pending_jobs = []
+      if !nonblocking.nil?
+        @nonblocking = nonblocking
+      end
+    end
+
+    def nonblocking?
+      @nonblocking
     end
 
     # Get a Source instance from this dataloader, for calling `.load(...)` or `.request(...)` on.
@@ -50,7 +67,7 @@ module GraphQL
     # @param batch_parameters [Array<Object>]
     # @return [GraphQL::Dataloader::Source] An instance of {source_class}, initialized with `self, *batch_parameters`,
     #   and cached for the lifetime of this {Multiplex}.
-    if RUBY_VERSION < "3"
+    if RUBY_VERSION < "3" || RUBY_ENGINE != "ruby" # truffle-ruby wasn't doing well with the implementation below
       def with(source_class, *batch_args)
         batch_key = source_class.batch_key_for(*batch_args)
         @source_cache[source_class][batch_key] ||= begin
@@ -117,6 +134,9 @@ module GraphQL
 
     # @api private Move along, move along
     def run
+      if @nonblocking && !Fiber.scheduler
+        raise "`nonblocking: true` requires `Fiber.scheduler`, assign one with `Fiber.set_scheduler(...)` before executing GraphQL."
+      end
       # At a high level, the algorithm is:
       #
       #  A) Inside Fibers, run jobs from the queue one-by-one
@@ -137,6 +157,8 @@ module GraphQL
       #
       pending_fibers = []
       next_fibers = []
+      pending_source_fibers = []
+      next_source_fibers = []
       first_pass = true
 
       while first_pass || (f = pending_fibers.shift)
@@ -174,31 +196,27 @@ module GraphQL
           # This is where an evented approach would be even better -- can we tell which
           # fibers are ready to continue, and continue execution there?
           #
-          source_fiber_queue = if (first_source_fiber = create_source_fiber)
-            [first_source_fiber]
-          else
-            nil
+          if (first_source_fiber = create_source_fiber)
+            pending_source_fibers << first_source_fiber
           end
 
-          if source_fiber_queue
-            while (outer_source_fiber = source_fiber_queue.shift)
+          while pending_source_fibers.any?
+            while (outer_source_fiber = pending_source_fibers.pop)
               resume(outer_source_fiber)
-
-              # If this source caused more sources to become pending, run those before running this one again:
-              next_source_fiber = create_source_fiber
-              if next_source_fiber
-                source_fiber_queue << next_source_fiber
-              end
-
               if outer_source_fiber.alive?
-                source_fiber_queue << outer_source_fiber
+                next_source_fibers << outer_source_fiber
+              end
+              if (next_source_fiber = create_source_fiber)
+                pending_source_fibers << next_source_fiber
               end
             end
+            join_queues(pending_source_fibers, next_source_fibers)
+            next_source_fibers.clear
           end
           # Move newly-enqueued Fibers on to the list to be resumed.
           # Clear out the list of next-round Fibers, so that
           # any Fibers that pause can be put on it.
-          pending_fibers.concat(next_fibers)
+          join_queues(pending_fibers, next_fibers)
           next_fibers.clear
         end
       end
@@ -213,6 +231,14 @@ module GraphQL
       nil
     end
 
+    def join_queues(previous_queue, next_queue)
+      if @nonblocking
+        Fiber.scheduler.run
+        next_queue.select!(&:alive?)
+      end
+      previous_queue.concat(next_queue)
+    end
+
     private
 
     # If there are pending sources, return a fiber for running them.
@@ -266,9 +292,16 @@ module GraphQL
         fiber_locals[fiber_var_key] = Thread.current[fiber_var_key]
       end
 
-      Fiber.new do
-        fiber_locals.each { |k, v| Thread.current[k] = v }
-        yield
+      if @nonblocking
+        Fiber.new(blocking: false) do
+          fiber_locals.each { |k, v| Thread.current[k] = v }
+          yield
+        end
+      else
+        Fiber.new do
+          fiber_locals.each { |k, v| Thread.current[k] = v }
+          yield
+        end
       end
     end
   end

data/lib/graphql/deprecation.rb

@@ -3,11 +3,7 @@
 module GraphQL
   module Deprecation
     def self.warn(message)
-      if defined?(ActiveSupport::Deprecation)
-        ActiveSupport::Deprecation.warn(message)
-      else
-        Kernel.warn(message)
-      end
+      Kernel.warn(message)
     end
   end
 end

data/lib/graphql/directive.rb

@@ -105,7 +105,3 @@ module GraphQL
     end
   end
 end
-
-require "graphql/directive/include_directive"
-require "graphql/directive/skip_directive"
-require "graphql/directive/deprecated_directive"

data/lib/graphql/enum_type.rb

@@ -34,10 +34,14 @@ module GraphQL
     end
 
     # @return [Hash<String => EnumValue>] `{name => value}` pairs contained in this type
-    def values
+    def values(_context = nil)
       @values_by_name
     end
 
+    def enum_values(_context = nil)
+      values.values
+    end
+
     def kind
       GraphQL::TypeKinds::ENUM
     end

data/lib/graphql/execution/errors.rb

@@ -111,6 +111,7 @@ module GraphQL
           runtime_info = ctx.namespace(:interpreter) || {}
           obj = runtime_info[:current_object]
           args = runtime_info[:current_arguments]
+          args = args && args.keyword_arguments
           field = runtime_info[:current_field]
           if obj.is_a?(GraphQL::Schema::Object)
             obj = obj.object

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

@@ -59,7 +59,7 @@ module GraphQL
           @empty
         end
 
-        def_delegators :keyword_arguments, :key?, :[], :fetch, :keys, :each, :values
+        def_delegators :keyword_arguments, :key?, :[], :fetch, :keys, :each, :values, :size, :to_h
         def_delegators :argument_values, :each_value
 
         def inspect

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

@@ -71,11 +71,11 @@ module GraphQL
           when Array
             ast_arg_or_hash_or_value.map { |v| prepare_args_hash(query, v) }
           when GraphQL::Language::Nodes::Field, GraphQL::Language::Nodes::InputObject, GraphQL::Language::Nodes::Directive
-            if ast_arg_or_hash_or_value.arguments.empty?
+            if ast_arg_or_hash_or_value.arguments.empty? # rubocop:disable Development/ContextIsPassedCop -- AST-related
               return NO_ARGUMENTS
             end
             args_hash = {}
-            ast_arg_or_hash_or_value.arguments.each do |arg|
+            ast_arg_or_hash_or_value.arguments.each do |arg| # rubocop:disable Development/ContextIsPassedCop -- AST-related
               v = prepare_args_hash(query, arg.value)
               if v != NO_VALUE_GIVEN
                 args_hash[arg.name] = v

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

@@ -314,7 +314,7 @@ module GraphQL
               case node
               when GraphQL::Language::Nodes::InlineFragment
                 if node.type
-                  type_defn = schema.get_type(node.type.name)
+                  type_defn = schema.get_type(node.type.name, context)
 
                   # Faster than .map{}.include?()
                   query.warden.possible_types(type_defn).each do |t|
@@ -329,7 +329,7 @@ module GraphQL
                 end
               when GraphQL::Language::Nodes::FragmentSpread
                 fragment_def = query.fragments[node.name]
-                type_defn = schema.get_type(fragment_def.type.name)
+                type_defn = query.get_type(fragment_def.type.name)
                 possible_types = query.warden.possible_types(type_defn)
                 possible_types.each do |t|
                   if t == owner_type
@@ -384,7 +384,9 @@ module GraphQL
             ast_node = field_ast_nodes_or_ast_node
           end
           field_name = ast_node.name
-          field_defn = @fields_cache[owner_type][field_name] ||= owner_type.get_field(field_name)
+          # This can't use `query.get_field` because it gets confused on introspection below if `field_defn` isn't `nil`,
+          # because of how `is_introspection` is used to call `.authorized_new` later on.
+          field_defn = @fields_cache[owner_type][field_name] ||= owner_type.get_field(field_name, @context)
           is_introspection = false
           if field_defn.nil?
             field_defn = if owner_type == schema.query && (entry_point_field = schema.introspection_system.entry_point(name: field_name))
@@ -419,10 +421,10 @@ module GraphQL
             object = authorized_new(field_defn.owner, object, context)
           end
 
-          total_args_count = field_defn.arguments.size
+          total_args_count = field_defn.arguments(context).size
           if total_args_count == 0
-            kwarg_arguments = GraphQL::Execution::Interpreter::Arguments::EMPTY
-            evaluate_selection_with_args(kwarg_arguments, field_defn, next_path, ast_node, field_ast_nodes, scoped_context, owner_type, object, is_eager_field, result_name, selections_result, parent_object)
+            resolved_arguments = GraphQL::Execution::Interpreter::Arguments::EMPTY
+            evaluate_selection_with_args(resolved_arguments, field_defn, next_path, ast_node, field_ast_nodes, scoped_context, owner_type, object, is_eager_field, result_name, selections_result, parent_object)
           else
             # TODO remove all arguments(...) usages?
             @query.arguments_cache.dataload_for(ast_node, field_defn, object) do |resolved_arguments|
@@ -431,10 +433,10 @@ module GraphQL
           end
         end
 
-        def evaluate_selection_with_args(kwarg_arguments, field_defn, next_path, ast_node, field_ast_nodes, scoped_context, owner_type, object, is_eager_field, result_name, selection_result, parent_object)  # rubocop:disable Metrics/ParameterLists
+        def evaluate_selection_with_args(arguments, field_defn, next_path, ast_node, field_ast_nodes, scoped_context, owner_type, object, is_eager_field, result_name, selection_result, parent_object)  # rubocop:disable Metrics/ParameterLists
           context.scoped_context = scoped_context
           return_type = field_defn.type
-          after_lazy(kwarg_arguments, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments, result_name: result_name, result: selection_result) do |resolved_arguments|
+          after_lazy(arguments, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, scoped_context: context.scoped_context, owner_object: object, arguments: arguments, result_name: result_name, result: selection_result) do |resolved_arguments|
             if resolved_arguments.is_a?(GraphQL::ExecutionError) || resolved_arguments.is_a?(GraphQL::UnauthorizedError)
               continue_value(next_path, resolved_arguments, owner_type, field_defn, return_type.non_null?, ast_node, result_name, selection_result)
               next
@@ -485,7 +487,7 @@ module GraphQL
               resolved_arguments.keyword_arguments
             end
 
-            set_all_interpreter_context(nil, nil, kwarg_arguments, nil)
+            set_all_interpreter_context(nil, nil, resolved_arguments, nil)
 
             # Optimize for the case that field is selected only once
             if field_ast_nodes.nil? || field_ast_nodes.size == 1
@@ -511,7 +513,7 @@ module GraphQL
               rescue GraphQL::ExecutionError => err
                 err
               end
-              after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments, result_name: result_name, result: selection_result) do |inner_result|
+              after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, scoped_context: context.scoped_context, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result) do |inner_result|
                 continue_value = continue_value(next_path, inner_result, owner_type, field_defn, return_type.non_null?, ast_node, result_name, selection_result)
                 if HALT != continue_value
                   continue_field(next_path, continue_value, owner_type, field_defn, return_type, ast_node, next_selections, false, object, kwarg_arguments, result_name, selection_result)
@@ -637,14 +639,20 @@ module GraphQL
           when Array
             # It's an array full of execution errors; add them all.
             if value.any? && value.all? { |v| v.is_a?(GraphQL::ExecutionError) }
+              list_type_at_all = (field && (field.type.list?))
               if selection_result.nil? || !dead_result?(selection_result)
                 value.each_with_index do |error, index|
                   error.ast_node ||= ast_node
-                  error.path ||= path + ((field && field.type.list?) ? [index] : [])
+                  error.path ||= path + (list_type_at_all ? [index] : [])
                   context.errors << error
                 end
                 if selection_result
-                  set_result(selection_result, result_name, nil)
+                  if list_type_at_all
+                    result_without_errors = value.map { |v| v.is_a?(GraphQL::ExecutionError) ? nil : v }
+                    set_result(selection_result, result_name, result_without_errors)
+                  else
+                    set_result(selection_result, result_name, nil)
+                  end
                 end
               end
               HALT

data/lib/graphql/execution/lookahead.rb

@@ -254,14 +254,14 @@ module GraphQL
             subselections_on_type = selections_on_type
             if (t = ast_selection.type)
               # Assuming this is valid, that `t` will be found.
-              on_type = @query.schema.get_type(t.name).type_class
+              on_type = @query.get_type(t.name).type_class
               subselections_on_type = subselections_by_type[on_type] ||= {}
             end
             find_selections(subselections_by_type, subselections_on_type, on_type, ast_selection.selections, arguments)
           when GraphQL::Language::Nodes::FragmentSpread
             frag_defn = @query.fragments[ast_selection.name] || raise("Invariant: Can't look ahead to nonexistent fragment #{ast_selection.name} (found: #{@query.fragments.keys})")
             # Again, assuming a valid AST
-            on_type = @query.schema.get_type(frag_defn.type.name).type_class
+            on_type = @query.get_type(frag_defn.type.name).type_class
             subselections_on_type = subselections_by_type[on_type] ||= {}
             find_selections(subselections_by_type, subselections_on_type, on_type, frag_defn.selections, arguments)
           else

data/lib/graphql/execution/multiplex.rb

@@ -35,7 +35,7 @@ module GraphQL
         @queries = queries
         @queries.each { |q| q.multiplex = self }
         @context = context
-        @context[:dataloader] = @dataloader = @schema.dataloader_class.new
+        @dataloader = @context[:dataloader] ||= @schema.dataloader_class.new
         @tracers = schema.tracers + (context[:tracers] || [])
         # Support `context: {backtrace: true}`
         if context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)