graphql 0.16.0 → 2.0.15

data/lib/graphql/execution/errors.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Errors
+      # Register this handler, updating the
+      # internal handler index to maintain least-to-most specific.
+      #
+      # @param error_class [Class<Exception>]
+      # @param error_handlers [Hash]
+      # @param error_handler [Proc]
+      # @return [void]
+      def self.register_rescue_from(error_class, error_handlers, 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)
+        while (error_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`.)
+          error_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|
+            error_handlers.delete(err_class)
+          end
+
+          # See if any keys in this hash are superclasses of this new class:
+          next_index_point = error_handlers.find { |err_class, handler| error_class < err_class }
+          if next_index_point
+            error_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 = error_handlers[error_class]
+        this_class_handlers[:handler] = error_handler
+        this_class_handlers[:subclass_handlers].merge!(subclasses_handlers)
+        nil
+      end
+
+      # @return [Proc, nil] The handler for `error_class`, if one was registered on this schema or inherited
+      def self.find_handler_for(schema, error_class)
+        handlers = schema.error_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_handlers)
+          parent_handler = find_handler_for(schema.superclass, 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/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/execution_errors.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      class ExecutionErrors
+        def initialize(ctx, ast_node, path)
+          @context = ctx
+          @ast_node = ast_node
+          @path = path
+        end
+
+        def add(err_or_msg)
+          err = case err_or_msg
+          when String
+            GraphQL::ExecutionError.new(err_or_msg)
+          when GraphQL::ExecutionError
+            err_or_msg
+          else
+            raise ArgumentError, "expected String or GraphQL::ExecutionError, not #{err_or_msg.class} (#{err_or_msg.inspect})"
+          end
+          err.ast_node ||= @ast_node
+          err.path ||= @path
+          @context.add_error(err)
+        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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      module Resolve
+        # Continue field results in `results` until there's nothing else to continue.
+        # @return [void]
+        def self.resolve_all(results, dataloader)
+          dataloader.append_job { resolve(results, dataloader) }
+          nil
+        end
+
+        # After getting `results` back from an interpreter evaluation,
+        # continue it until you get a response-ready Ruby value.
+        #
+        # `results` is one level of _depth_ of a query or multiplex.
+        #
+        # Resolve all lazy values in that depth before moving on
+        # to the next level.
+        #
+        # It's assumed that the lazies will
+        # return {Lazy} instances if there's more work to be done,
+        # or return {Hash}/{Array} if the query should be continued.
+        #
+        # @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 = []
+          while results.any?
+            result_value = results.shift
+            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)
+              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
+
+          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
+
+          nil
+        end
+      end
+    end
+  end
+end