graphql 2.6.11 → 2.6.13

data/lib/graphql/date_encoding_error.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   # This error is raised when `Types::ISO8601Date` is asked to return a value
   # that cannot be parsed to a Ruby Date.
   #
-  # @see GraphQL::Types::ISO8601Date which raises this error
+  # See [GraphQL::Types::ISO8601Date](rdoc-ref:GraphQL::Types::ISO8601Date) which raises this error
   class DateEncodingError < GraphQL::RuntimeTypeError
     # The value which couldn't be encoded
     attr_reader :date_value

data/lib/graphql/dig.rb

@@ -1,13 +1,22 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   module Dig
     # implemented using the old activesupport #dig instead of the ruby built-in
     # so we can use some of the magic in Schema::InputObject and Interpreter::Arguments
     # to handle stringified/symbolized keys.
     #
-    # @param own_key [String, Symbol] A key to retrieve
-    # @param rest_keys [Array<[String, Symbol>] Retrieves the value object corresponding to the each key objects repeatedly
-    # @return [Object]
+    # **Parameters**
+    #
+    # - `own_key` (`String, Symbol`) — A key to retrieve
+    # - `rest_keys` (`Array<[String, Symbol]>`) — Keys to use for retrieving nested values
+    #
+    # **Returns**
+    #
+    # - `Object`
+    #
+    # :call-seq:
+    #   dig(String | Symbol own_key, Array[[String, Symbol]] *rest_keys) -> Object
     def dig(own_key, *rest_keys)
       val = self[own_key]
       if val.nil? || rest_keys.empty?

data/lib/graphql/duration_encoding_error.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   # This error is raised when `Types::ISO8601Duration` is asked to return a value
   # that cannot be parsed as an ISO8601-formatted duration by ActiveSupport::Duration.
   #
-  # @see GraphQL::Types::ISO8601Duration which raises this error
+  # See [GraphQL::Types::ISO8601Duration](rdoc-ref:GraphQL::Types::ISO8601Duration) which raises this error
   class DurationEncodingError < GraphQL::RuntimeTypeError
     # The value which couldn't be encoded
     attr_reader :duration_value

data/lib/graphql/execution/directive_checks.rb

@@ -1,16 +1,21 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   module Execution
     # Boolean checks for how an AST node's directives should
     # influence its execution
-    # @api private
-    module DirectiveChecks
+    module DirectiveChecks # :nodoc:
       SKIP = "skip"
       INCLUDE = "include"
 
       module_function
 
-      # @return [Boolean] Should this node be included in the query?
+      # **Returns**
+      #
+      # - `Boolean` — Should this node be included in the query?
+      #
+      # :call-seq:
+      #   include?(directive_ast_nodes, query) -> bool
       def include?(directive_ast_nodes, query)
         directive_ast_nodes.each do |directive_ast_node|
           name = directive_ast_node.name

data/lib/graphql/execution/errors.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Execution
@@ -6,10 +7,18 @@ module GraphQL
       # 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]
+      # **Parameters**
+      #
+      # - `error_class` (`Class<Exception>`)
+      # - `error_handlers` (`Hash`)
+      # - `error_handler` (`Proc`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   register_rescue_from(Class[Exception] error_class, Hash error_handlers, Proc error_handler) -> void
       def self.register_rescue_from(error_class, error_handlers, error_handler)
         subclasses_handlers = {}
         this_level_subclasses = []
@@ -52,10 +61,15 @@ module GraphQL
         nil
       end
 
-      # @return [Proc, nil] The handler for `error_class`, if one was registered on this schema or inherited
+      # **Returns**
+      #
+      # - `Proc, nil` — The handler for `error_class`, if one was registered on this schema or inherited
+      #
+      # :call-seq:
+      #   find_handler_for(schema, error_class) -> Proc | nil
       def self.find_handler_for(schema, error_class)
         handlers = schema.error_handlers[:subclass_handlers]
-        handler = nil
+        handler = nil #: untyped
         while (handlers) do
           _err_class, next_handler = handlers.find { |err_class, handler| error_class <= err_class }
           if next_handler

data/lib/graphql/execution/field_resolve_step.rb

@@ -1,7 +1,12 @@
 # frozen_string_literal: true
+# typed: false
 module GraphQL
   module Execution
     class FieldResolveStep
+      # Only these built-in fields on Relay connection and edge types return already-scoped items.
+      # Custom fields on those types must still be authorized normally.
+      SCOPED_RELAY_FIELD_NAMES = [:node, :nodes, :edges].freeze
+
       def initialize(parent_type:, runner:, key:, selections_step:)
         @selections_step = selections_step
         @key = key
@@ -283,7 +288,7 @@ module GraphQL
           authorized_objects = objects
         end
 
-        if @parent_type.default_relay? && authorized_objects.all? { |o| o.respond_to?(:was_authorized_by_scope_items?) && o.was_authorized_by_scope_items? }
+        if @parent_type.default_relay? && SCOPED_RELAY_FIELD_NAMES.include?(@field_definition.original_name) && authorized_objects.all? { |o| o.respond_to?(:was_authorized_by_scope_items?) && o.was_authorized_by_scope_items? }
           @was_scoped = true
         end
 
@@ -414,11 +419,15 @@ module GraphQL
           case ext
           when Schema::Field::ConnectionExtension
             conns = ctx.schema.connections
+            lookahead = @arguments[:lookahead]
+            # The memo omits the extension's extras (`:lookahead`)
+            conn_arguments = memos[@finish_extension_idx] || @arguments
             @field_results.map!.each_with_index do |value, idx|
               object = @extended.object[idx]
-              conn = conns.populate_connection(@field_definition, object, value, @arguments, ctx)
+              conn = conns.populate_connection(@field_definition, object, value, conn_arguments, ctx)
               if conn
                 conn.was_authorized_by_scope_items = @was_scoped
+                conn.lookahead ||= lookahead
               end
               conn
             rescue GraphQL::RuntimeError => err
@@ -510,7 +519,7 @@ module GraphQL
       def build_leaf_result(result_h, result_key, field_result, return_type, ctx, is_from_array)
         if field_result.nil?
           if return_type.non_null?
-            add_non_null_error(is_from_array)
+            add_non_null_error(is_from_array, return_type: return_type)
           else
             nil
           end
@@ -527,7 +536,7 @@ module GraphQL
           end
 
           inner_type = return_type.of_type
-          result_a = Array.new(field_result.size)
+          result_a = field_result.is_a?(Array) ? Array.new(field_result.size) : []
           field_result.each_with_index do |item, idx|
             result_a[idx] = build_leaf_result(result_a, idx, item, inner_type, ctx, true)
           end
@@ -605,8 +614,14 @@ module GraphQL
         end
       end
 
-      def add_non_null_error(is_from_array)
-        err = @parent_type::InvalidNullError.new(@parent_type, @field_definition, ast_nodes, is_from_array: is_from_array, path: path)
+      def add_non_null_error(is_from_array, return_type: nil)
+        if is_from_array && return_type
+          list_type = @field_definition.type
+          list_type = list_type.of_type if list_type.non_null?
+          # Preserve existing messages for single-level lists.
+          element_type = return_type.of_type if list_type.of_type.list?
+        end
+        err = @parent_type::InvalidNullError.new(@parent_type, @field_definition, ast_nodes, is_from_array: is_from_array, path: path, element_type: element_type)
         nn_result = @runner.schema.type_error(err, @selections_step.query.context)
         if nn_result.nil?
           propagate_nulls
@@ -645,11 +660,18 @@ module GraphQL
           list_result = graphql_result[key] = []
           @directive_finalizers&.each { |f| @runner.add_finalizer(@selections_step.query, list_result, nil, f) }
           i = 0
-          s = field_result.size
-          while i < s
-            inner_f_r = field_result[i]
-            build_graphql_result(list_result, i, inner_f_r, inner_type, inner_type_nn, inner_type_l, true)
-            i += 1
+          if field_result.is_a?(Array)
+            s = field_result.size
+            while i < s
+              inner_f_r = field_result[i]
+              build_graphql_result(list_result, i, inner_f_r, inner_type, inner_type_nn, inner_type_l, true)
+              i += 1
+            end
+          else
+            field_result.each do |inner_f_r|
+              build_graphql_result(list_result, i, inner_f_r, inner_type, inner_type_nn, inner_type_l, true)
+              i += 1
+            end
           end
         elsif @runner.resolves_lazies || (
                 @static_type.kind.object? ?
@@ -786,8 +808,13 @@ module GraphQL
           end
           results
         when :resolve_legacy_instance_method
-          @selections_step.graphql_objects.map do |obj_inst|
-            obj_inst.public_send(@field_definition.execution_mode_key, **args_hash)
+          graphql_objects = if objects.equal?(@selections_step.objects)
+            @selections_step.graphql_objects
+          else
+            objects.map { |object| @parent_type.scoped_new(object, context) }
+          end
+          graphql_objects.map do |graphql_object|
+            graphql_object.public_send(@field_definition.execution_mode_key, **args_hash)
           rescue GraphQL::ExecutionError => exec_err
             exec_err
           end

data/lib/graphql/execution/finalize.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   module Execution
     class Finalize
@@ -39,11 +40,16 @@ module GraphQL
                 tf[key] = err
                 @finalizers_count += 1
               elsif value_at_key.is_a?(Array)
-                value_at_key.each_with_index do |el, idx|
-                  if el.equal?(err)
-                    tf = @finalizers[value_at_key] ||= {}.compare_by_identity
-                    tf[idx] = err
-                    @finalizers_count += 1
+                pending_arrays = [value_at_key]
+                while (array = pending_arrays.pop)
+                  array.each_with_index do |el, idx|
+                    if el.equal?(err)
+                      array_tf = @finalizers[array] ||= {}.compare_by_identity
+                      array_tf[idx] = err
+                      @finalizers_count += 1
+                    elsif el.is_a?(Array)
+                      pending_arrays << el
+                    end
                   end
                 end
               end
@@ -175,7 +181,7 @@ module GraphQL
           inner_type = inner_type.of_type
         end
 
-        new_invalid_null = false
+        new_invalid_null = false #: bool
 
         if (f = finalizers(result_arr, nil))
           run_finalizers(@current_result_path.dup, f, result_arr, nil)

data/lib/graphql/execution/input_values.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   module Execution
     class InputValues
@@ -38,7 +39,7 @@ module GraphQL
       def argument_values(owner_defn, argument_nodes, field_resolve_step)
         arg_defns = @query.types.arguments(owner_defn)
         argument_values = {}
-        errors = nil
+        errors = nil #: untyped
 
         arg_defns.each do |argument_definition|
           arg_ruby_key = argument_definition.keyword

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

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
+# typed: 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.
+      # See [Interpreter::Arguments#argument_values](rdoc-ref:Interpreter::Arguments#argument_values) for a hash of these objects.
       class ArgumentValue
         def initialize(definition:, value:, original_value:, default_used:)
           @definition = definition
@@ -13,16 +14,27 @@ module GraphQL
           @default_used = default_used
         end
 
-        # @return [Object] The Ruby-ready value for this Argument
+        # **Returns**
+        #
+        # - `Object` — The Ruby-ready value for this Argument
         attr_reader :value
 
-        # @return [Object] The value of this argument _before_ `prepare` is applied.
+        # **Returns**
+        #
+        # - `Object` — The value of this argument _before_ `prepare` is applied.
         attr_reader :original_value
 
-        # @return [GraphQL::Schema::Argument] The definition instance for this argument
+        # **Returns**
+        #
+        # - `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.)
+        # **Returns**
+        #
+        # - `Boolean` — `true` if the schema-defined `default_value:` was applied in this case. (No client-provided value was present.)
+        #
+        # :call-seq:
+        #   default_used?() -> bool
         def default_used?
           @default_used
         end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Execution
@@ -8,7 +9,7 @@ module GraphQL
       # 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.
+      # See [GraphQL::Query#arguments_for](rdoc-ref:GraphQL::Query#arguments_for) to get access to these objects.
       class Arguments
         extend Forwardable
         include GraphQL::Dig
@@ -16,11 +17,18 @@ module GraphQL
         # The Ruby-style arguments hash, ready for a resolver.
         # This hash is the one used at runtime.
         #
-        # @return [Hash<Symbol, Object>]
+        # **Returns**
+        #
+        # - `Hash<Symbol, Object>`
         attr_reader :keyword_arguments
 
-        # @param argument_values [nil, Hash{Symbol => ArgumentValue}]
-        # @param keyword_arguments [nil, Hash{Symbol => Object}]
+        # **Parameters**
+        #
+        # - `argument_values` (`nil, Hash{Symbol => ArgumentValue}`)
+        # - `keyword_arguments` (`nil, Hash{Symbol => Object}`)
+        #
+        # :call-seq:
+        #   initialize(nil | Hash[Symbol, Object] keyword_arguments:, nil | Hash[Symbol, ArgumentValue] argument_values:)
         def initialize(keyword_arguments: nil, argument_values:)
           @empty = argument_values.nil? || argument_values.empty?
           # This is only present when `extras` have been merged in:
@@ -52,7 +60,9 @@ module GraphQL
           freeze
         end
 
-        # @return [Hash{Symbol => ArgumentValue}]
+        # **Returns**
+        #
+        # - `Hash{Symbol => ArgumentValue}`
         attr_reader :argument_values
 
         def empty?
@@ -70,10 +80,15 @@ module GraphQL
         #
         # 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)
+        #
+        # **Parameters**
+        #
+        # - `extra_args` (`Hash<Symbol => Object>`)
+        #
+        # **Returns**
+        #
+        # - `Interpreter::Arguments`
+        def merge_extras(extra_args) # :nodoc:
           self.class.new(
             argument_values: argument_values,
             keyword_arguments: keyword_arguments.merge(extra_args)

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Execution
@@ -36,7 +37,7 @@ module GraphQL
           @storage[argument_owner][nil][ast_node]
         end
 
-        # @yield [Interpreter::Arguments, Lazy<Interpreter::Arguments>] The finally-loaded arguments
+        # **Yields:** [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
           arg_storage = @storage[argument_owner][parent_object]

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Execution

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Execution

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

@@ -1,23 +1,32 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Execution
     class Interpreter
       module Resolve
         # Continue field results in `results` until there's nothing else to continue.
-        # @return [void]
-        # @deprecated Call `dataloader.run` instead
+        # **Deprecated:** Call `dataloader.run` instead
+        #
+        # **Returns**
+        #
+        # - `void`
+        #
+        # :call-seq:
+        #   resolve_all(results, dataloader) -> void
         def self.resolve_all(results, dataloader)
-          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{caller(1, 5).map { |l| "\n    #{l}"}.join}"
+          backtrace = caller(1, 5) #: as !nil
+          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{backtrace.map { |l| "\n    #{l}"}.join}"
           dataloader.append_job { resolve(results, dataloader) }
           nil
         end
 
-        # @deprecated Call `dataloader.run` instead
+        # **Deprecated:** Call `dataloader.run` instead
         def self.resolve_each_depth(lazies_at_depth, dataloader)
-          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{caller(1, 5).map { |l| "\n    #{l}"}.join}"
+          backtrace = caller(1, 5) #: as !nil
+          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{backtrace.map { |l| "\n    #{l}"}.join}"
 
-          smallest_depth = nil
+          smallest_depth = nil #: Integer?
           lazies_at_depth.each_key do |depth_key|
             smallest_depth ||= depth_key
             if depth_key < smallest_depth
@@ -39,9 +48,10 @@ module GraphQL
           nil
         end
 
-        # @deprecated Call `dataloader.run` instead
+        # **Deprecated:** Call `dataloader.run` instead
         def self.resolve(results, dataloader)
-          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{caller(1, 5).map { |l| "\n    #{l}"}.join}"
+          backtrace = caller(1, 5) #: as !nil
+          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{backtrace.map { |l| "\n    #{l}"}.join}"
           # 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.

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Execution
@@ -54,7 +55,9 @@ module GraphQL
           attr_reader :graphql_parent, :graphql_result_name, :graphql_is_non_null_in_parent,
             :graphql_application_value, :graphql_result_type, :graphql_selections, :graphql_is_eager, :ast_node, :graphql_arguments, :graphql_field
 
-          # @return [Hash] Plain-Ruby result data (`@graphql_metadata` contains Result wrapper objects)
+          # **Returns**
+          #
+          # - `Hash` — Plain-Ruby result data (`@graphql_metadata` contains Result wrapper objects)
           attr_accessor :graphql_result_data
         end