graphql 2.6.9 → 2.6.14

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
 

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 require "graphql/execution/interpreter/runtime/graphql_result"
 
 module GraphQL
@@ -7,8 +8,7 @@ module GraphQL
       # I think it would be even better if we could somehow make
       # `continue_field` not recursive. "Trampolining" it somehow.
       #
-      # @api private
-      class Runtime
+      class Runtime # :nodoc:
         class CurrentState
           def initialize
             @current_field = nil
@@ -26,13 +26,19 @@ module GraphQL
             :current_arguments, :current_field, :was_authorized_by_scope_items
         end
 
-        # @return [GraphQL::Query]
+        # **Returns**
+        #
+        # - `GraphQL::Query`
         attr_reader :query
 
-        # @return [Class<GraphQL::Schema>]
+        # **Returns**
+        #
+        # - `Class<GraphQL::Schema>`
         attr_reader :schema
 
-        # @return [GraphQL::Query::Context]
+        # **Returns**
+        #
+        # - `GraphQL::Query::Context`
         attr_reader :context
 
         def initialize(query:)
@@ -63,7 +69,12 @@ module GraphQL
           "#<#{self.class.name} response=#{@response.inspect}>"
         end
 
-        # @return [void]
+        # **Returns**
+        #
+        # - `void`
+        #
+        # :call-seq:
+        #   run_eager() -> void
         def run_eager
           root_type = query.root_type
           case query
@@ -138,7 +149,7 @@ module GraphQL
             else
               @response = GraphQLResultArray.new(nil, root_type, nil, nil, false, selections, false, ast_node, nil, nil)
               @response.base_path = base_path
-              idx = nil
+              idx = nil #: Integer?
               object.each do |inner_value|
                 idx ||= 0
                 this_idx = idx
@@ -209,6 +220,7 @@ module GraphQL
           end
         end
 
+        #: (untyped, untyped, untyped, untyped, Array[untyped]?, untyped, untyped) -> untyped
         def gather_selections(graphql_response, owner_object, owner_type, selections, selections_to_run, selections_by_name, ordered_result_keys)
           selections.each do |node|
             if node.is_a?(GraphQL::Language::Nodes::Field)
@@ -242,7 +254,7 @@ module GraphQL
                 if selections_to_run
                   selections_to_run << next_selections
                 else
-                  selections_to_run = []
+                  selections_to_run = [] #: Array[untyped]
                   selections_to_run << selections_by_name
                   selections_to_run << next_selections
                 end
@@ -253,7 +265,10 @@ module GraphQL
               case node
               when GraphQL::Language::Nodes::InlineFragment
                 if node.type
-                  type_defn = query.types.type(node.type.name)
+                  type_defn = query.types.type(
+                    node.type #: as !nil
+                    .name
+                  )
 
                   if query.types.possible_types(type_defn).include?(owner_type)
                     result = gather_selections(graphql_response, owner_object, owner_type, node.selections, selections_to_run, next_selections, ordered_result_keys)
@@ -287,7 +302,12 @@ module GraphQL
 
         NO_ARGS = GraphQL::EmptyObjects::EMPTY_HASH
 
-        # @return [void]
+        # **Returns**
+        #
+        # - `void`
+        #
+        # :call-seq:
+        #   evaluate_selections(gathered_selections, selections_result, target_result, runtime_state) -> void
         def evaluate_selections(gathered_selections, selections_result, target_result, runtime_state) # rubocop:disable Metrics/ParameterLists
           runtime_state ||= get_current_runtime_state
           runtime_state.current_result_name = nil
@@ -325,7 +345,12 @@ module GraphQL
           end
         end
 
-        # @return [void]
+        # **Returns**
+        #
+        # - `void`
+        #
+        # :call-seq:
+        #   evaluate_selection(result_name, field_ast_nodes_or_ast_node, selections_result) -> void
         def evaluate_selection(result_name, field_ast_nodes_or_ast_node, selections_result) # rubocop:disable Metrics/ParameterLists
           return if selections_result.graphql_dead
           # As a performance optimization, the hash key will be a `Node` if
@@ -374,6 +399,7 @@ module GraphQL
           end
         end
 
+        #: (untyped, untyped, untyped, Array[untyped]?, untyped, untyped, untyped, untyped) -> untyped
         def evaluate_selection_with_args(arguments, field_defn, ast_node, field_ast_nodes, object, result_name, selection_result, runtime_state)  # rubocop:disable Metrics/ParameterLists
           after_lazy(arguments, field: field_defn, ast_node: ast_node, owner_object: object, arguments: arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |resolved_arguments, runtime_state|
             if resolved_arguments.is_a?(GraphQL::ExecutionError) || resolved_arguments.is_a?(GraphQL::UnauthorizedError)
@@ -405,7 +431,7 @@ module GraphQL
                   extra_args[:path] = current_path
                 when :lookahead
                   if !field_ast_nodes
-                    field_ast_nodes = [ast_node]
+                    field_ast_nodes = [ast_node] #: Array[untyped]
                   end
 
                   extra_args[:lookahead] = Execution::Lookahead.new(
@@ -556,9 +582,13 @@ module GraphQL
               set_result(selection_result, result_name, nil, false, is_non_null) do
                 # When this comes from a list item, use the parent object:
                 is_from_array = selection_result.is_a?(GraphQLResultArray)
-                parent_type = is_from_array ? selection_result.graphql_parent.graphql_result_type : selection_result.graphql_result_type
+                parent_result = selection_result
+                until parent_result.is_a?(GraphQLResultHash)
+                  parent_result = parent_result.graphql_parent
+                end
+                parent_type = parent_result.graphql_result_type
                 # This block is called if `result_name` is not dead. (Maybe a previous invalid nil caused it be marked dead.)
-                err = parent_type::InvalidNullError.new(parent_type, field, ast_node, is_from_array: is_from_array)
+                err = parent_type.const_get(:InvalidNullError).new(parent_type, field, ast_node, is_from_array: is_from_array)
                 schema.type_error(err, context)
               end
             else
@@ -619,7 +649,9 @@ module GraphQL
           when Array
             # It's an array full of execution errors; add them all.
             if !value.empty? && value.all?(GraphQL::ExecutionError)
-              list_type_at_all = (field && (field.type.list?))
+              list_type = field && field.type
+              list_type = list_type.of_type if list_type && list_type.non_null?
+              list_type_at_all = list_type && list_type.list?
               if selection_result.nil? || !selection_result.graphql_dead
                 value.each_with_index do |error, index|
                   error.ast_node ||= ast_node
@@ -627,7 +659,7 @@ module GraphQL
                   context.errors << error
                 end
                 if selection_result
-                  if list_type_at_all
+                  if list_type_at_all && !list_type.of_type.non_null?
                     result_without_errors = value.map { |v| v.is_a?(GraphQL::ExecutionError) ? nil : v }
                     set_result(selection_result, result_name, result_without_errors, false, is_non_null)
                   else
@@ -655,7 +687,12 @@ module GraphQL
         #
         # Location information from `path` and `ast_node`.
         #
-        # @return [Lazy, Array, Hash, Object] Lazy, Array, and Hash are all traversed to resolve lazy values later
+        # **Returns**
+        #
+        # - `Lazy, Array, Hash, Object` — Lazy, Array, and Hash are all traversed to resolve lazy values later
+        #
+        # :call-seq:
+        #   continue_field(value, owner_type, field, current_type, ast_node, next_selections, is_non_null, owner_object, arguments, result_name, selection_result, was_scoped, runtime_state) -> Lazy | Array | Hash | Object
         def continue_field(value, owner_type, field, current_type, ast_node, next_selections, is_non_null, owner_object, arguments, result_name, selection_result, was_scoped, runtime_state) # rubocop:disable Metrics/ParameterLists
           if current_type.non_null?
             current_type = current_type.of_type
@@ -700,7 +737,7 @@ module GraphQL
               possible_types = query.types.possible_types(current_type)
               if !possible_types.include?(resolved_type)
                 parent_type = field.owner_type
-                err_class = current_type::UnresolvedTypeError
+                err_class = current_type.const_get(:UnresolvedTypeError)
                 type_error = err_class.new(resolved_value, field, parent_type, resolved_type, possible_types)
                 schema.type_error(type_error, context)
                 set_result(selection_result, result_name, nil, false, is_non_null)
@@ -747,7 +784,7 @@ module GraphQL
             inner_type_non_null = inner_type.non_null?
             response_list = GraphQLResultArray.new(result_name, current_type, owner_object, selection_result, is_non_null, next_selections, false, ast_node, arguments, field)
             set_result(selection_result, result_name, response_list, true, is_non_null)
-            idx = nil
+            idx = nil #: Integer?
             list_value = begin
               begin
                 value.each do |inner_value|
@@ -798,6 +835,8 @@ module GraphQL
 
         def resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state) # rubocop:disable Metrics/ParameterLists
           runtime_state ||= get_current_runtime_state
+          runtime_state.current_field = field
+          runtime_state.current_arguments = arguments
           runtime_state.current_result_name = this_idx
           runtime_state.current_result = response_list
           call_method_on_directives(:resolve_each, owner_object, ast_node.directives) do
@@ -849,7 +888,7 @@ module GraphQL
           end
         end
 
-        # Check {Schema::Directive.include?} for each directive that's present
+        # Check [Schema::Directive.include?](rdoc-ref:Schema::Directive.include?) for each directive that's present
         def directives_include?(node, graphql_object, parent_type, selection_result, extra_path_part)
           node.directives.each do |dir_node|
             dir_defn = @schema_directives.fetch(dir_node.name)
@@ -898,11 +937,19 @@ module GraphQL
           end
         end
 
-        # @param obj [Object] Some user-returned value that may want to be batched
-        # @param field [GraphQL::Schema::Field]
-        # @param eager [Boolean] Set to `true` for mutation root fields only
-        # @param trace [Boolean] If `false`, don't wrap this with field tracing
-        # @return [GraphQL::Execution::Lazy, Object] If loading `object` will be deferred, it's a wrapper over it.
+        # **Parameters**
+        #
+        # - `obj` (`Object`) — Some user-returned value that may want to be batched
+        # - `field` (`GraphQL::Schema::Field`)
+        # - `eager` (`Boolean`) — Set to `true` for mutation root fields only
+        # - `trace` (`Boolean`) — If `false`, don't wrap this with field tracing
+        #
+        # **Returns**
+        #
+        # - `GraphQL::Execution::Lazy, Object` — If loading `object` will be deferred, it's a wrapper over it.
+        #
+        # :call-seq:
+        #   after_lazy(lazy_obj, GraphQL::Schema::Field field:, owner_object:, arguments:, ast_node:, result:, result_name:, bool eager:, runtime_state:, bool trace:, &block) -> GraphQL::Execution::Lazy | Object
         def after_lazy(lazy_obj, field:, owner_object:, arguments:, ast_node:, result:, result_name:, eager: false, runtime_state:, trace: true, &block)
           if lazy?(lazy_obj)
             was_authorized_by_scope_items = runtime_state.was_authorized_by_scope_items

data/lib/graphql/execution/interpreter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 require "fiber"
 require "graphql/execution/interpreter/argument_value"
 require "graphql/execution/interpreter/arguments"
@@ -13,15 +14,24 @@ module GraphQL
     class Interpreter
       class << self
         # Used internally to signal that the query shouldn't be executed
-        # @api private
+        # :nodoc:
         NO_OPERATION = GraphQL::EmptyObjects::EMPTY_HASH
 
-        # @param schema [GraphQL::Schema]
-        # @param queries [Array<GraphQL::Query, Hash>]
-        # @param context [Hash]
-        # @param max_complexity [Integer, nil]
-        # @return [Array<GraphQL::Query::Result>] One result per query
+        # **Parameters**
+        #
+        # - `schema` (`GraphQL::Schema`)
+        # - `queries` (`Array<GraphQL::Query, Hash>`)
+        # - `context` (`Hash`)
+        # - `max_complexity` (`Integer, nil`)
+        #
+        # **Returns**
+        #
+        # - `Array<GraphQL::Query::Result>` — One result per query
+        #
+        # :call-seq:
+        #   run_all(GraphQL::Schema schema, query_options, Hash context:, Integer | nil max_complexity:) -> Array[GraphQL::Query::Result]
         def run_all(schema, query_options, context: {}, max_complexity: schema.max_complexity)
+          previous_multiplex = Fiber[:__graphql_current_multiplex]
           queries = query_options.map do |opts|
             query = case opts
             when Hash
@@ -131,7 +141,6 @@ module GraphQL
               queries.map { |q| q.result_values ||= {} }
               raise
             ensure
-              Fiber[:__graphql_current_multiplex] = nil
               queries.map { |query|
                 runtime = query.context.namespace(:interpreter_runtime)[:runtime]
                 if runtime
@@ -140,6 +149,8 @@ module GraphQL
               }
             end
           end
+        ensure
+          Fiber[:__graphql_current_multiplex] = previous_multiplex
         end
       end
 

data/lib/graphql/execution/lazy/lazy_method_map.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 require 'thread'
 begin
   require 'concurrent'
@@ -9,13 +10,12 @@ end
 module GraphQL
   module Execution
     class Lazy
-      # {GraphQL::Schema} uses this to match returned values to lazy resolution methods.
+      # [GraphQL::Schema](rdoc-ref:GraphQL::Schema) uses this to match returned values to lazy resolution methods.
       # Methods may be registered for classes, they apply to its subclasses also.
       # The result of this lookup is cached for future resolutions.
       # Instances of this class are thread-safe.
-      # @api private
-      # @see {Schema#lazy?} looks up values from this map
-      class LazyMethodMap
+      # See the schema's `lazy?` configuration to understand which values use this map.
+      class LazyMethodMap # :nodoc:
         def initialize(use_concurrent: defined?(Concurrent::Map))
           @storage = use_concurrent ? Concurrent::Map.new : ConcurrentishMap.new
         end
@@ -24,14 +24,27 @@ module GraphQL
           @storage = other.storage.dup
         end
 
-        # @param lazy_class [Class] A class which represents a lazy value (subclasses may also be used)
-        # @param lazy_value_method [Symbol] The method to call on this class to get its value
+        # **Parameters**
+        #
+        # - `lazy_class` (`Class`) — A class which represents a lazy value (subclasses may also be used)
+        # - `lazy_value_method` (`Symbol`) — The method to call on this class to get its value
+        #
+        # :call-seq:
+        #   set(Class lazy_class, Symbol lazy_value_method)
         def set(lazy_class, lazy_value_method)
           @storage[lazy_class] = lazy_value_method
         end
 
-        # @param value [Object] an object which may have a `lazy_value_method` registered for its class or superclasses
-        # @return [Symbol, nil] The `lazy_value_method` for this object, or nil
+        # **Parameters**
+        #
+        # - `value` (`Object`) — an object which may have a `lazy_value_method` registered for its class or superclasses
+        #
+        # **Returns**
+        #
+        # - `Symbol, nil` — The `lazy_value_method` for this object, or nil
+        #
+        # :call-seq:
+        #   get(Object value) -> Symbol | nil
         def get(value)
           @storage.compute_if_absent(value.class) { find_superclass_method(value.class) }
         end

data/lib/graphql/execution/lazy.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 require "graphql/execution/lazy/lazy_method_map"
 
 module GraphQL
@@ -10,20 +11,30 @@ module GraphQL
     # This is an itty-bitty promise-like object, with key differences:
     # - It has only two states, not-resolved and resolved
     # - It has no error-catching functionality
-    # @api private
-    class Lazy
+    class Lazy # :nodoc:
       attr_reader :field
 
-      # Create a {Lazy} which will get its inner value by calling the block
-      # @param field [GraphQL::Schema::Field]
-      # @param get_value_func [Proc] a block to get the inner value (later)
+      # Create a [Lazy](rdoc-ref:Lazy) which will get its inner value by calling the block
+      #
+      # **Parameters**
+      #
+      # - `field` (`GraphQL::Schema::Field`)
+      # - `get_value_func` (`Proc`) — a block to get the inner value (later)
+      #
+      # :call-seq:
+      #   initialize(GraphQL::Schema::Field field:, Proc &get_value_func)
       def initialize(field: nil, &get_value_func)
         @get_value_func = get_value_func
         @resolved = false
         @field = field
       end
 
-      # @return [Object] The wrapped value, calling the lazy block if necessary
+      # **Returns**
+      #
+      # - `Object` — The wrapped value, calling the lazy block if necessary
+      #
+      # :call-seq:
+      #   value() -> Object
       def value
         if !@resolved
           @resolved = true
@@ -45,15 +56,28 @@ module GraphQL
         end
       end
 
-      # @return [Lazy] A {Lazy} whose value depends on another {Lazy}, plus any transformations in `block`
+      # **Returns**
+      #
+      # - `Lazy` — A [Lazy](rdoc-ref:Lazy) whose value depends on another [Lazy](rdoc-ref:Lazy), plus any transformations in `block`
+      #
+      # :call-seq:
+      #   then() -> Lazy
       def then
         self.class.new {
           yield(value)
         }
       end
 
-      # @param lazies [Array<Object>] Maybe-lazy objects
-      # @return [Lazy] A lazy which will sync all of `lazies`
+      # **Parameters**
+      #
+      # - `lazies` (`Array<Object>`) — Maybe-lazy objects
+      #
+      # **Returns**
+      #
+      # - `Lazy` — A lazy which will sync all of `lazies`
+      #
+      # :call-seq:
+      #   all(Array[Object] lazies) -> Lazy
       def self.all(lazies)
         self.new {
           lazies.map { |l| l.is_a?(Lazy) ? l.value : l }
@@ -61,7 +85,7 @@ module GraphQL
       end
 
       # This can be used for fields which _had no_ lazy results
-      # @api private
+      # :nodoc:
       NullResult = Lazy.new(){}
       NullResult.value
     end

data/lib/graphql/execution/load_argument_step.rb

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