graphql 1.11.6 → 1.13.19

data/lib/graphql/execution/errors.rb

@@ -18,17 +18,83 @@ module GraphQL
     #
     class Errors
       def self.use(schema)
-        schema.error_handler = self.new(schema)
+        definition_line = caller(2, 1).first
+        GraphQL::Deprecation.warn("GraphQL::Execution::Errors is now installed by default, remove `use GraphQL::Execution::Errors` from #{definition_line}")
       end
 
+      NEW_HANDLER_HASH = ->(h, k) {
+        h[k] = {
+          class: k,
+          handler: nil,
+          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
+         }
+      }
+
       def initialize(schema)
         @schema = schema
+        @handlers = {
+          class: nil,
+          handler: nil,
+          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
+        }
       end
 
-      class NullErrorHandler
-        def self.with_error_handling(_ctx)
-          yield
+      # @api private
+      def each_rescue
+        handlers = @handlers.values
+        while (handler = handlers.shift) do
+          yield(handler[:class], handler[:handler])
+          handlers.concat(handler[:subclass_handlers].values)
+        end
+      end
+
+      # Register this handler, updating the
+      # internal handler index to maintain least-to-most specific.
+      #
+      # @param error_class [Class<Exception>]
+      # @param error_handler [Proc]
+      # @return [void]
+      def rescue_from(error_class, error_handler)
+        subclasses_handlers = {}
+        this_level_subclasses = []
+        # During this traversal, do two things:
+        # - Identify any already-registered subclasses of this error class
+        #   and gather them up to be inserted _under_ this class
+        # - Find the point in the index where this handler should be inserted
+        #   (That is, _under_ any superclasses, or at top-level, if there are no superclasses registered)
+        handlers = @handlers[:subclass_handlers]
+        while (handlers) do
+          this_level_subclasses.clear
+          # First, identify already-loaded handlers that belong
+          # _under_ this one. (That is, they're handlers
+          # for subclasses of `error_class`.)
+          handlers.each do |err_class, handler|
+            if err_class < error_class
+              subclasses_handlers[err_class] = handler
+              this_level_subclasses << err_class
+            end
+          end
+          # Any handlers that we'll be moving, delete them from this point in the index
+          this_level_subclasses.each do |err_class|
+            handlers.delete(err_class)
+          end
+
+          # See if any keys in this hash are superclasses of this new class:
+          next_index_point = handlers.find { |err_class, handler| error_class < err_class }
+          if next_index_point
+            handlers = next_index_point[1][:subclass_handlers]
+          else
+            # this new handler doesn't belong to any sub-handlers,
+            # so insert it in the current set of `handlers`
+            break
+          end
         end
+        # Having found the point at which to insert this handler,
+        # register it and merge any subclass handlers back in at this point.
+        this_class_handlers = handlers[error_class]
+        this_class_handlers[:handler] = error_handler
+        this_class_handlers[:subclass_handlers].merge!(subclasses_handlers)
+        nil
       end
 
       # Call the given block with the schema's configured error handlers.
@@ -40,21 +106,58 @@ module GraphQL
       def with_error_handling(ctx)
         yield
       rescue StandardError => err
-        rescues = ctx.schema.rescues
-        _err_class, handler = rescues.find { |err_class, handler| err.is_a?(err_class) }
+        handler = find_handler_for(err.class)
         if handler
           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
           end
-          handler.call(err, obj, args, ctx, field)
+          handler[:handler].call(err, obj, args, ctx, field)
         else
           raise err
         end
       end
+
+      # @return [Proc, nil] The handler for `error_class`, if one was registered on this schema or inherited
+      def find_handler_for(error_class)
+        handlers = @handlers[:subclass_handlers]
+        handler = nil
+        while (handlers) do
+          _err_class, next_handler = handlers.find { |err_class, handler| error_class <= err_class }
+          if next_handler
+            handlers = next_handler[:subclass_handlers]
+            handler = next_handler
+          else
+            # Don't reassign `handler` --
+            # let the previous assignment carry over outside this block.
+            break
+          end
+        end
+
+        # check for a handler from a parent class:
+        if @schema.superclass.respond_to?(:error_handler) && (parent_errors = @schema.superclass.error_handler)
+          parent_handler = parent_errors.find_handler_for(error_class)
+        end
+
+        # If the inherited handler is more specific than the one defined here,
+        # use it.
+        # If it's a tie (or there is no parent handler), use the one defined here.
+        # If there's an inherited one, but not one defined here, use the inherited one.
+        # Otherwise, there's no handler for this error, return `nil`.
+        if parent_handler && handler && parent_handler[:class] < handler[:class]
+          parent_handler
+        elsif handler
+          handler
+        elsif parent_handler
+          parent_handler
+        else
+          nil
+        end
+      end
     end
   end
 end

data/lib/graphql/execution/execute.rb

@@ -6,7 +6,7 @@ module GraphQL
     class Execute
 
       # @api private
-      class Skip; end
+      class Skip < GraphQL::Error; end
 
       # Just a singleton for implementing {Query::Context#skip}
       # @api private
@@ -18,7 +18,14 @@ module GraphQL
       # @api private
       PROPAGATE_NULL = PropagateNull.new
 
+      def self.use(schema_class)
+        schema_class.query_execution_strategy(self)
+        schema_class.mutation_execution_strategy(self)
+        schema_class.subscription_execution_strategy(self)
+      end
+
       def execute(ast_operation, root_type, query)
+        GraphQL::Deprecation.warn "#{self.class} will be removed in GraphQL-Ruby 2.0, please upgrade to the Interpreter: https://graphql-ruby.org/queries/interpreter.html"
         result = resolve_root_selection(query)
         lazy_resolve_root_selection(result, **{query: query})
         GraphQL::Execution::Flatten.call(query.context)

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

@@ -5,6 +5,9 @@ module GraphQL
     class Interpreter
       # A wrapper for argument hashes in GraphQL queries.
       #
+      # This object is immutable so that the runtime code can be sure that
+      # modifications don't leak from one use to another
+      #
       # @see GraphQL::Query#arguments_for to get access to these objects.
       class Arguments
         extend Forwardable
@@ -16,20 +19,69 @@ module GraphQL
         # @return [Hash<Symbol, Object>]
         attr_reader :keyword_arguments
 
-        def initialize(keyword_arguments:, argument_values:)
-          @keyword_arguments = keyword_arguments
-          @argument_values = argument_values
+        # @param argument_values [nil, Hash{Symbol => ArgumentValue}]
+        # @param keyword_arguments [nil, Hash{Symbol => Object}]
+        def initialize(keyword_arguments: nil, argument_values:)
+          @empty = argument_values.nil? || argument_values.empty?
+          # This is only present when `extras` have been merged in:
+          if keyword_arguments
+            # This is a little crazy. We expect the `:argument_details` extra to _include extras_,
+            # but the object isn't created until _after_ extras are put together.
+            # So, we have to use a special flag here to say, "at the last minute, add yourself to the keyword args."
+            #
+            # Otherwise:
+            # - We can't access the final Arguments instance _while_ we're preparing extras
+            # - After we _can_ access it, it's frozen, so we can't add anything.
+            #
+            # So, this flag gives us a chance to sneak it in before freezing, _and_ while we have access
+            # to the new Arguments instance itself.
+            if keyword_arguments[:argument_details] == :__arguments_add_self
+              keyword_arguments[:argument_details] = self
+            end
+            @keyword_arguments = keyword_arguments.freeze
+          elsif !@empty
+            @keyword_arguments = {}
+            argument_values.each do |name, arg_val|
+              @keyword_arguments[name] = arg_val.value
+            end
+            @keyword_arguments.freeze
+          else
+            @keyword_arguments = NO_ARGS
+          end
+          @argument_values = argument_values ? argument_values.freeze : NO_ARGS
+          freeze
         end
 
         # @return [Hash{Symbol => ArgumentValue}]
         attr_reader :argument_values
 
-        def_delegators :@keyword_arguments, :key?, :[], :fetch, :keys, :each, :values
-        def_delegators :@argument_values, :each_value
+        def empty?
+          @empty
+        end
+
+        def_delegators :keyword_arguments, :key?, :[], :fetch, :keys, :each, :values, :size, :to_h
+        def_delegators :argument_values, :each_value
 
         def inspect
           "#<#{self.class} @keyword_arguments=#{keyword_arguments.inspect}>"
         end
+
+        # Create a new arguments instance which includes these extras.
+        #
+        # This is called by the runtime to implement field `extras: [...]`
+        #
+        # @param extra_args [Hash<Symbol => Object>]
+        # @return [Interpreter::Arguments]
+        # @api private
+        def merge_extras(extra_args)
+          self.class.new(
+            argument_values: argument_values,
+            keyword_arguments: keyword_arguments.merge(extra_args)
+          )
+        end
+
+        NO_ARGS = {}.freeze
+        EMPTY = self.new(argument_values: nil, keyword_arguments: NO_ARGS).freeze
       end
     end
   end

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
@@ -24,36 +28,66 @@ module GraphQL
         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.)
+          if !@storage.key?(ast_node) || !@storage[ast_node].key?(argument_owner)
+            @dataloader.run_isolated do
+              @storage[ast_node][argument_owner][parent_object]
+            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)
+          nil
+        end
+
         private
 
+        NO_ARGUMENTS = {}.freeze
+
         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?
+              return NO_ARGUMENTS
+            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? # rubocop:disable Development/ContextIsPassedCop -- AST-related
+              return NO_ARGUMENTS
+            end
             args_hash = {}
-            ast_arg_or_hash_or_value.arguments.each do |arg|
-              v = prepare_args_hash(arg.value)
+            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
               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/handles_raw_value.rb

@@ -13,13 +13,6 @@ module GraphQL
           @object
         end
       end
-
-      # Allows to return "raw" value from the resolver
-      module HandlesRawValue
-        def raw_value(obj)
-          RawValue.new(obj)
-        end
-      end
     end
   end
 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,46 @@ 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?(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)
-              # 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?(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
+              end
             end
           end
 
-          next_results
+          if next_results.any?
+            dataloader.append_job { resolve(next_results, dataloader) }
+          end
+
+          nil
         end
       end
     end