graphql 1.12.12 → 2.2.14

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

@@ -7,55 +7,57 @@ module GraphQL
         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|
-                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
-
-                if !h3.key?(parent_object)
-                  # TODO should i bother putting anything here?
-                  h3[parent_object] = NO_ARGUMENTS
-                else
-                  h3[parent_object]
-                end
+          @storage = Hash.new do |h, argument_owner|
+            args_by_parent = if argument_owner.arguments_statically_coercible?
+              shared_values_cache = {}
+              Hash.new do |h2, ignored_parent_object|
+                h2[ignored_parent_object] = shared_values_cache
+              end
+            else
+              Hash.new do |h2, parent_object|
+                args_by_node = {}
+                args_by_node.compare_by_identity
+                h2[parent_object] = args_by_node
               end
             end
+            args_by_parent.compare_by_identity
+            h[argument_owner] = args_by_parent
           end
+          @storage.compare_by_identity
         end
 
         def fetch(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_isolated do
-            @storage[ast_node][argument_owner][parent_object]
+          # This runs eagerly if no block is given
+          @storage[argument_owner][parent_object][ast_node] ||= begin
+            args_hash = self.class.prepare_args_hash(@query, ast_node)
+            kwarg_arguments = argument_owner.coerce_arguments(parent_object, args_hash, @query.context)
+            @query.after_lazy(kwarg_arguments) do |resolved_args|
+              @storage[argument_owner][parent_object][ast_node] = resolved_args
+            end
           end
-          # 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)
+          arg_storage = @storage[argument_owner][parent_object]
+          if (args = arg_storage[ast_node])
+            yield(args)
+          else
+            args_hash = self.class.prepare_args_hash(@query, ast_node)
+            argument_owner.coerce_arguments(parent_object, args_hash, @query.context) do |resolved_args|
+              arg_storage[ast_node] = resolved_args
+              yield(resolved_args)
+            end
+          end
           nil
         end
 
         private
 
-        NO_ARGUMENTS = {}.freeze
-
-        NO_VALUE_GIVEN = Object.new
+        NO_ARGUMENTS = GraphQL::EmptyObjects::EMPTY_HASH
+        NO_VALUE_GIVEN = NOT_CONFIGURED
 
         def self.prepare_args_hash(query, ast_arg_or_hash_or_value)
           case ast_arg_or_hash_or_value
@@ -71,11 +73,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/resolve.rb

@@ -11,6 +11,25 @@ module GraphQL
           nil
         end
 
+        def self.resolve_each_depth(lazies_at_depth, dataloader)
+          depths = lazies_at_depth.keys
+          depths.sort!
+          next_depth = depths.first
+          if next_depth
+            lazies = lazies_at_depth[next_depth]
+            lazies_at_depth.delete(next_depth)
+            if lazies.any?
+              dataloader.append_job {
+                lazies.each(&:value) # resolve these Lazy instances
+              }
+              # Run lazies _and_ dataloader, see if more are enqueued
+              dataloader.run
+              resolve_each_depth(lazies_at_depth, dataloader)
+            end
+          end
+          nil
+        end
+
         # After getting `results` back from an interpreter evaluation,
         # continue it until you get a response-ready Ruby value.
         #
@@ -34,7 +53,10 @@ module GraphQL
           next_results = []
           while results.any?
             result_value = results.shift
-            if result_value.is_a?(Hash)
+            if result_value.is_a?(Runtime::GraphQLResultHash) || result_value.is_a?(Hash)
+              results.concat(result_value.values)
+              next
+            elsif result_value.is_a?(Runtime::GraphQLResultArray)
               results.concat(result_value.values)
               next
             elsif result_value.is_a?(Array)
@@ -46,7 +68,8 @@ module GraphQL
                 # 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)
+              elsif loaded_value.is_a?(Runtime::GraphQLResultHash) || loaded_value.is_a?(Runtime::GraphQLResultArray) ||
+                  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
@@ -55,6 +78,13 @@ module GraphQL
           end
 
           if next_results.any?
+            # Any pending data loader jobs may populate the
+            # resutl arrays or result hashes accumulated in
+            # `next_results``. Run those **to completion**
+            # before continuing to resolve `next_results`.
+            # (Just `.append_job` doesn't work if any pending
+            # jobs require multiple passes.)
+            dataloader.run
             dataloader.append_job { resolve(next_results, dataloader) }
           end
 

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

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      class Runtime
+        module GraphQLResult
+          def initialize(result_name, parent_result, is_non_null_in_parent)
+            @graphql_parent = parent_result
+            if parent_result && parent_result.graphql_dead
+              @graphql_dead = true
+            end
+            @graphql_result_name = result_name
+            @graphql_is_non_null_in_parent = is_non_null_in_parent
+            # Jump through some hoops to avoid creating this duplicate storage if at all possible.
+            @graphql_metadata = nil
+          end
+
+          def path
+            @path ||= build_path([])
+          end
+
+          def build_path(path_array)
+            graphql_result_name && path_array.unshift(graphql_result_name)
+            @graphql_parent ? @graphql_parent.build_path(path_array) : path_array
+          end
+
+          attr_accessor :graphql_dead
+          attr_reader :graphql_parent, :graphql_result_name, :graphql_is_non_null_in_parent
+
+          # @return [Hash] Plain-Ruby result data (`@graphql_metadata` contains Result wrapper objects)
+          attr_accessor :graphql_result_data
+        end
+
+        class GraphQLResultHash
+          def initialize(_result_name, _parent_result, _is_non_null_in_parent)
+            super
+            @graphql_result_data = {}
+          end
+
+          include GraphQLResult
+
+          attr_accessor :graphql_merged_into
+
+          def set_leaf(key, value)
+            # This is a hack.
+            # Basically, this object is merged into the root-level result at some point.
+            # But the problem is, some lazies are created whose closures retain reference to _this_
+            # object. When those lazies are resolved, they cause an update to this object.
+            #
+            # In order to return a proper top-level result, we have to update that top-level result object.
+            # In order to return a proper partial result (eg, for a directive), we have to update this object, too.
+            # Yowza.
+            if (t = @graphql_merged_into)
+              t.set_leaf(key, value)
+            end
+
+            @graphql_result_data[key] = value
+            # keep this up-to-date if it's been initialized
+            @graphql_metadata && @graphql_metadata[key] = value
+
+            value
+          end
+
+          def set_child_result(key, value)
+            if (t = @graphql_merged_into)
+              t.set_child_result(key, value)
+            end
+            @graphql_result_data[key] = value.graphql_result_data
+            # If we encounter some part of this response that requires metadata tracking,
+            # then create the metadata hash if necessary. It will be kept up-to-date after this.
+            (@graphql_metadata ||= @graphql_result_data.dup)[key] = value
+            value
+          end
+
+          def delete(key)
+            @graphql_metadata && @graphql_metadata.delete(key)
+            @graphql_result_data.delete(key)
+          end
+
+          def each
+            (@graphql_metadata || @graphql_result_data).each { |k, v| yield(k, v) }
+          end
+
+          def values
+            (@graphql_metadata || @graphql_result_data).values
+          end
+
+          def key?(k)
+            @graphql_result_data.key?(k)
+          end
+
+          def [](k)
+            (@graphql_metadata || @graphql_result_data)[k]
+          end
+
+          def merge_into(into_result)
+            self.each do |key, value|
+              case value
+              when GraphQLResultHash
+                next_into = into_result[key]
+                if next_into
+                  value.merge_into(next_into)
+                else
+                  into_result.set_child_result(key, value)
+                end
+              when GraphQLResultArray
+                # There's no special handling of arrays because currently, there's no way to split the execution
+                # of a list over several concurrent flows.
+                into_result.set_child_result(key, value)
+              else
+                # We have to assume that, since this passed the `fields_will_merge` selection,
+                # that the old and new values are the same.
+                into_result.set_leaf(key, value)
+              end
+            end
+            @graphql_merged_into = into_result
+          end
+        end
+
+        class GraphQLResultArray
+          include GraphQLResult
+
+          def initialize(_result_name, _parent_result, _is_non_null_in_parent)
+            super
+            @graphql_result_data = []
+          end
+
+          def graphql_skip_at(index)
+            # Mark this index as dead. It's tricky because some indices may already be storing
+            # `Lazy`s. So the runtime is still holding indexes _before_ skipping,
+            # this object has to coordinate incoming writes to account for any already-skipped indices.
+            @skip_indices ||= []
+            @skip_indices << index
+            offset_by = @skip_indices.count { |skipped_idx| skipped_idx < index}
+            delete_at_index = index - offset_by
+            @graphql_metadata && @graphql_metadata.delete_at(delete_at_index)
+            @graphql_result_data.delete_at(delete_at_index)
+          end
+
+          def set_leaf(idx, value)
+            if @skip_indices
+              offset_by = @skip_indices.count { |skipped_idx| skipped_idx < idx }
+              idx -= offset_by
+            end
+            @graphql_result_data[idx] = value
+            @graphql_metadata && @graphql_metadata[idx] = value
+            value
+          end
+
+          def set_child_result(idx, value)
+            if @skip_indices
+              offset_by = @skip_indices.count { |skipped_idx| skipped_idx < idx }
+              idx -= offset_by
+            end
+            @graphql_result_data[idx] = value.graphql_result_data
+            # If we encounter some part of this response that requires metadata tracking,
+            # then create the metadata hash if necessary. It will be kept up-to-date after this.
+            (@graphql_metadata ||= @graphql_result_data.dup)[idx] = value
+            value
+          end
+
+          def values
+            (@graphql_metadata || @graphql_result_data)
+          end
+        end
+      end
+    end
+  end
+end