graphql 1.12.3 → 1.12.4

data/lib/graphql/dataloader/null_dataloader.rb

@@ -7,15 +7,15 @@ module GraphQL
     # The Dataloader interface isn't public, but it enables
     # simple internal code while adding the option to add Dataloader.
     class NullDataloader < Dataloader
-      def enqueue
-        yield
-      end
-
       # These are all no-ops because code was
       # executed sychronously.
       def run; end
       def yield; end
-      def yielded?(_path); false; end
+
+      def append_job
+        yield
+        nil
+      end
     end
   end
 end

data/lib/graphql/dataloader/request.rb

@@ -12,12 +12,7 @@ module GraphQL
       #
       # @return [Object] the object loaded for `key`
       def load
-        if @source.results.key?(@key)
-          @source.results[@key]
-        else
-          @source.sync
-          @source.results[@key]
-        end
+        @source.load(@key)
       end
     end
   end

data/lib/graphql/dataloader/request_all.rb

@@ -12,10 +12,7 @@ module GraphQL
       #
       # @return [Array<Object>] One object for each of `keys`
       def load
-        if @keys.any? { |k| !@source.results.key?(k) }
-          @source.sync
-        end
-        @keys.map { |k| @source.results[k] }
+        @source.load_all(@keys)
       end
     end
   end

data/lib/graphql/dataloader/source.rb

@@ -3,9 +3,6 @@
 module GraphQL
   class Dataloader
     class Source
-      # @api private
-      attr_reader :results
-
       # Called by {Dataloader} to prepare the {Source}'s internal state
       # @api private
       def setup(dataloader)
@@ -35,11 +32,11 @@ module GraphQL
       # @return [Object] The result from {#fetch} for `key`. If `key` hasn't been loaded yet, the Fiber will yield until it's loaded.
       def load(key)
         if @results.key?(key)
-          @results[key]
+          result_for(key)
         else
           @pending_keys << key
           sync
-          @results[key]
+          result_for(key)
         end
       end
 
@@ -52,7 +49,7 @@ module GraphQL
           sync
         end
 
-        keys.map { |k| @results[k] }
+        keys.map { |k| result_for(k) }
       end
 
       # Subclasses must implement this method to return a value for each of `keys`
@@ -86,8 +83,25 @@ module GraphQL
         fetch_keys.each_with_index do |key, idx|
           @results[key] = results[idx]
         end
+      rescue StandardError => error
+        fetch_keys.each { |key| @results[key] = error }
+      ensure
         nil
       end
+
+      private
+
+      # Reads and returns the result for the key from the internal cache, or raises an error if the result was an error
+      # @param key [Object] key passed to {#load} or {#load_all}
+      # @return [Object] The result from {#fetch} for `key`.
+      # @api private
+      def result_for(key)
+        result = @results[key]
+
+        raise result if result.class <= StandardError
+
+        result
+      end
     end
   end
 end

data/lib/graphql/execution/interpreter.rb

@@ -95,7 +95,7 @@ module GraphQL
         end
         final_values.compact!
         tracer.trace("execute_query_lazy", {multiplex: multiplex, query: query}) do
-          Interpreter::Resolve.resolve_all(final_values)
+          Interpreter::Resolve.resolve_all(final_values, multiplex.dataloader)
         end
         queries.each do |query|
           runtime = query.context.namespace(:interpreter)[:runtime]

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

@@ -6,17 +6,21 @@ module GraphQL
       class ArgumentsCache
         def initialize(query)
           @query = query
+          @dataloader = query.context.dataloader
           @storage = Hash.new do |h, ast_node|
             h[ast_node] = Hash.new do |h2, arg_owner|
               h2[arg_owner] = Hash.new do |h3, parent_object|
-                # First, normalize all AST or Ruby values to a plain Ruby hash
-                args_hash = prepare_args_hash(ast_node)
-                # Then call into the schema to coerce those incoming values
-                args = arg_owner.coerce_arguments(parent_object, args_hash, query.context)
+                dataload_for(ast_node, arg_owner, parent_object) do |kwarg_arguments|
+                  h3[parent_object] = @query.schema.after_lazy(kwarg_arguments) do |resolved_args|
+                    h3[parent_object] = resolved_args
+                  end
+                end
 
-                h3[parent_object] = @query.schema.after_lazy(args) do |resolved_args|
-                  # when this promise is resolved, update the cache with the resolved value
-                  h3[parent_object] = resolved_args
+                if !h3.key?(parent_object)
+                  # TODO should i bother putting anything here?
+                  h3[parent_object] = NO_ARGUMENTS
+                else
+                  h3[parent_object]
                 end
               end
             end
@@ -25,6 +29,25 @@ module GraphQL
 
         def fetch(ast_node, argument_owner, parent_object)
           @storage[ast_node][argument_owner][parent_object]
+          # If any jobs were enqueued, run them now,
+          # since this might have been called outside of execution.
+          # (The jobs are responsible for updating `result` in-place.)
+          @dataloader.run
+          # Ack, the _hash_ is updated, but the key is eventually
+          # overridden with an immutable arguments instance.
+          # The first call queues up the job,
+          # then this call fetches the result.
+          # TODO this should be better, find a solution
+          # that works with merging the runtime.rb code
+          @storage[ast_node][argument_owner][parent_object]
+        end
+
+        # @yield [Interpreter::Arguments, Lazy<Interpreter::Arguments>] The finally-loaded arguments
+        def dataload_for(ast_node, argument_owner, parent_object, &block)
+          # First, normalize all AST or Ruby values to a plain Ruby hash
+          args_hash = self.class.prepare_args_hash(@query, ast_node)
+          argument_owner.coerce_arguments(parent_object, args_hash, @query.context, &block)
+          nil
         end
 
         private
@@ -33,7 +56,7 @@ module GraphQL
 
         NO_VALUE_GIVEN = Object.new
 
-        def prepare_args_hash(ast_arg_or_hash_or_value)
+        def self.prepare_args_hash(query, ast_arg_or_hash_or_value)
           case ast_arg_or_hash_or_value
           when Hash
             if ast_arg_or_hash_or_value.empty?
@@ -41,27 +64,27 @@ module GraphQL
             end
             args_hash = {}
             ast_arg_or_hash_or_value.each do |k, v|
-              args_hash[k] = prepare_args_hash(v)
+              args_hash[k] = prepare_args_hash(query, v)
             end
             args_hash
           when Array
-            ast_arg_or_hash_or_value.map { |v| prepare_args_hash(v) }
+            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?
               return NO_ARGUMENTS
             end
             args_hash = {}
             ast_arg_or_hash_or_value.arguments.each do |arg|
-              v = prepare_args_hash(arg.value)
+              v = prepare_args_hash(query, arg.value)
               if v != NO_VALUE_GIVEN
                 args_hash[arg.name] = v
               end
             end
             args_hash
           when GraphQL::Language::Nodes::VariableIdentifier
-            if @query.variables.key?(ast_arg_or_hash_or_value.name)
-              variable_value = @query.variables[ast_arg_or_hash_or_value.name]
-              prepare_args_hash(variable_value)
+            if query.variables.key?(ast_arg_or_hash_or_value.name)
+              variable_value = query.variables[ast_arg_or_hash_or_value.name]
+              prepare_args_hash(query, variable_value)
             else
               NO_VALUE_GIVEN
             end

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

@@ -6,10 +6,9 @@ module GraphQL
       module Resolve
         # Continue field results in `results` until there's nothing else to continue.
         # @return [void]
-        def self.resolve_all(results)
-          while results.any?
-            results = resolve(results)
-          end
+        def self.resolve_all(results, dataloader)
+          dataloader.append_job { resolve(results, dataloader) }
+          nil
         end
 
         # After getting `results` back from an interpreter evaluation,
@@ -24,33 +23,42 @@ module GraphQL
         # 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)
+        # @return [void]
+        def self.resolve(results, dataloader)
+          # There might be pending jobs here that _will_ write lazies
+          # into the result hash. We should run them out, so we
+          # can be sure that all lazies will be present in the result hashes.
+          # A better implementation would somehow interleave (or unify)
+          # these approaches.
+          dataloader.run
           next_results = []
-
-          # Work through the queue until it's empty
-          while results.size > 0
+          while results.any?
             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)
+            if result_value.is_a?(Hash)
+              results.concat(result_value.values)
+              next
             elsif result_value.is_a?(Array)
-              # This is part of the next level, add it
-              next_results.concat(result_value)
+              results.concat(result_value)
+              next
+            elsif result_value.is_a?(Lazy)
+              loaded_value = result_value.value
+              if loaded_value.is_a?(Lazy)
+                # Since this field returned another lazy,
+                # add it to the same queue
+                results << loaded_value
+              elsif loaded_value.is_a?(Hash) || loaded_value.is_a?(Array)
+                # Add these values in wholesale --
+                # they might be modified by later work in the dataloader.
+                next_results << loaded_value
+              end
             end
           end
 
-          next_results
+          if next_results.any?
+            dataloader.append_job { resolve(next_results, dataloader) }
+          end
+
+          nil
         end
       end
     end

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

@@ -56,17 +56,18 @@ module GraphQL
             # Root .authorized? returned false.
             write_in_response(path, nil)
           else
-            # Prepare this runtime state to be encapsulated in a Fiber
-            @progress_path = path
-            @progress_scoped_context = context.scoped_context
-            @progress_object = object_proxy
-            @progress_object_type = root_type
-            @progress_index = nil
-            @progress_is_eager_selection = root_op_type == "mutation"
-            @progress_selections = gather_selections(object_proxy, root_type, root_operation.selections)
-
+            gathered_selections = gather_selections(object_proxy, root_type, root_operation.selections)
             # Make the first fiber which will begin execution
-            enqueue_selections_fiber
+            @dataloader.append_job {
+              evaluate_selections(
+                path,
+                context.scoped_context,
+                object_proxy,
+                root_type,
+                root_op_type == "mutation",
+                gathered_selections,
+              )
+            }
           end
           delete_interpreter_context(:current_path)
           delete_interpreter_context(:current_field)
@@ -75,32 +76,6 @@ module GraphQL
           nil
         end
 
-        # Use `@dataloader` to enqueue a fiber that will pick up from the current point.
-        # @return [void]
-        def enqueue_selections_fiber
-          # Read these into local variables so that later assignments don't affect the block below.
-          path = @progress_path
-          scoped_context = @progress_scoped_context
-          owner_object = @progress_object
-          owner_type = @progress_object_type
-          idx = @progress_index
-          is_eager_selection = @progress_is_eager_selection
-          gathered_selections = @progress_selections
-
-          @dataloader.enqueue {
-            evaluate_selections(
-              path,
-              scoped_context,
-              owner_object,
-              owner_type,
-              is_eager_selection: is_eager_selection,
-              after: idx,
-              gathered_selections: gathered_selections,
-            )
-          }
-          nil
-        end
-
         def gather_selections(owner_object, owner_type, selections, selections_by_name = {})
           selections.each do |node|
             # Skip gathering this if the directive says so
@@ -159,39 +134,17 @@ module GraphQL
         NO_ARGS = {}.freeze
 
         # @return [void]
-        def evaluate_selections(path, scoped_context, owner_object, owner_type, is_eager_selection:, gathered_selections:, after:)
+        def evaluate_selections(path, scoped_context, owner_object, owner_type, is_eager_selection, gathered_selections)
           set_all_interpreter_context(owner_object, nil, nil, path)
 
-          @progress_path = path
-          @progress_scoped_context = scoped_context
-          @progress_object = owner_object
-          @progress_object_type = owner_type
-          @progress_index = nil
-          @progress_is_eager_selection = is_eager_selection
-          @progress_selections = gathered_selections
-
-          # Track `idx` manually to avoid an allocation on this hot path
-          idx = 0
           gathered_selections.each do |result_name, field_ast_nodes_or_ast_node|
-            prev_idx = idx
-            idx += 1
-            # TODO: this is how a `progress` resumes where this left off.
-            # Is there a better way to seek in the hash?
-            # I think we could also use the array of keys; it supports seeking just fine.
-            if after && prev_idx <= after
-              next
-            end
-            @progress_index = prev_idx
-            # This is how the current runtime gives itself to `dataloader`
-            # so that the dataloader can enqueue another fiber to resume if needed.
-            @dataloader.current_runtime = self
-            evaluate_selection(path, result_name, field_ast_nodes_or_ast_node, scoped_context, owner_object, owner_type, is_eager_selection)
-            # The dataloader knows if ^^ that selection halted and later selections were executed in another fiber.
-            # If that's the case, then don't continue execution here.
-            if @dataloader.yielded?(path)
-              break
-            end
+            @dataloader.append_job {
+              evaluate_selection(
+                path, result_name, field_ast_nodes_or_ast_node, scoped_context, owner_object, owner_type, is_eager_selection
+              )
+            }
           end
+
           nil
         end
 
@@ -243,13 +196,21 @@ module GraphQL
             object = authorized_new(field_defn.owner, object, context, next_path)
           end
 
-          begin
-            kwarg_arguments = arguments(object, field_defn, ast_node)
-          rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => e
-            continue_value(next_path, e, owner_type, field_defn, return_type.non_null?, ast_node)
-            return
+          total_args_count = field_defn.arguments.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)
+          else
+            # TODO remove all arguments(...) usages?
+            @query.arguments_cache.dataload_for(ast_node, field_defn, object) do |resolved_arguments|
+              evaluate_selection_with_args(resolved_arguments, field_defn, next_path, ast_node, field_ast_nodes, scoped_context, owner_type, object, is_eager_field)
+            end
           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)  # 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) 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)
@@ -329,10 +290,11 @@ module GraphQL
             # all of its child fields before moving on to the next root mutation field.
             # (Subselections of this mutation will still be resolved level-by-level.)
             if is_eager_field
-              Interpreter::Resolve.resolve_all([field_result])
+              Interpreter::Resolve.resolve_all([field_result], @dataloader)
+            else
+              # Return this from `after_lazy` because it might be another lazy that needs to be resolved
+              field_result
             end
-
-            nil
           end
         end
 
@@ -419,7 +381,7 @@ module GraphQL
                 response_hash = {}
                 write_in_response(path, response_hash)
                 gathered_selections = gather_selections(continue_value, current_type, next_selections)
-                evaluate_selections(path, context.scoped_context, continue_value, current_type, is_eager_selection: false, gathered_selections: gathered_selections, after: nil)
+                evaluate_selections(path, context.scoped_context, continue_value, current_type, false, gathered_selections)
                 response_hash
               end
             end