graphql 1.9.21 → 2.0.0

data/lib/graphql/execution/errors.rb

@@ -2,14 +2,11 @@
 
 module GraphQL
   module Execution
-    # A plugin that wraps query execution with error handling.
-    # Supports class-based schemas and the new {Interpreter} runtime only.
+    # A plugin that wraps query execution with error handling. Installed by default.
     #
     # @example Handling ActiveRecord::NotFound
     #
     #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Execution::Errors
-    #
     #     rescue_from(ActiveRecord::NotFound) do |err, obj, args, ctx, field|
     #       ErrorTracker.log("Not Found: #{err.message}")
     #       nil
@@ -17,19 +14,79 @@ module GraphQL
     #   end
     #
     class Errors
-      def self.use(schema)
-        schema_class = schema.is_a?(Class) ? schema : schema.target.class
-        schema_class.error_handler = self.new(schema_class)
-      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
+
+      # @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
 
-      class NullErrorHandler
-        def self.with_error_handling(_ctx)
-          yield
+      # 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.
@@ -41,21 +98,58 @@ module GraphQL
       def with_error_handling(ctx)
         yield
       rescue StandardError => err
-        rescues = @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/instrumentation.rb

@@ -77,7 +77,7 @@ module GraphQL
         end
 
         def call_after_hooks(instrumenters, object, after_hook_name, ex)
-          instrumenters.reverse.each do |instrumenter|
+          instrumenters.reverse_each do |instrumenter|
             begin
               instrumenter.public_send(after_hook_name, object)
             rescue => e

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      # A container for metadata regarding arguments present in a GraphQL query.
+      # @see Interpreter::Arguments#argument_values for a hash of these objects.
+      class ArgumentValue
+        def initialize(definition:, value:, default_used:)
+          @definition = definition
+          @value = value
+          @default_used = default_used
+        end
+
+        # @return [Object] The Ruby-ready value for this Argument
+        attr_reader :value
+
+        # @return [GraphQL::Schema::Argument] The definition instance for this argument
+        attr_reader :definition
+
+        # @return [Boolean] `true` if the schema-defined `default_value:` was applied in this case. (No client-provided value was present.)
+        def default_used?
+          @default_used
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    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
+        include GraphQL::Dig
+
+        # The Ruby-style arguments hash, ready for a resolver.
+        # This hash is the one used at runtime.
+        #
+        # @return [Hash<Symbol, Object>]
+        attr_reader :keyword_arguments
+
+        # @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 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
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      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|
+                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
+              end
+            end
+          end
+        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 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(query, v)
+            end
+            args_hash
+          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? # rubocop:disable Development/ContextIsPassedCop -- AST-related
+              return NO_ARGUMENTS
+            end
+            args_hash = {}
+            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(query, variable_value)
+            else
+              NO_VALUE_GIVEN
+            end
+          when GraphQL::Language::Nodes::Enum
+            ast_arg_or_hash_or_value.name
+          when GraphQL::Language::Nodes::NullValue
+            nil
+          else
+            ast_arg_or_hash_or_value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      # Wrapper for raw values
+      class RawValue
+        def initialize(obj = nil)
+          @object = obj
+        end
+
+        def resolve
+          @object
+        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