graphql 2.6.12 → 2.6.13

data/lib/graphql/schema/member/has_fields.rb

@@ -1,60 +1,80 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
     class Member
       # Shared code for Objects, Interfaces, Mutations, Subscriptions
+      #--
+      # @requires_ancestor: Kernel
+      # @requires_ancestor: Module
+      # @requires_ancestor: GraphQL::Schema::Member::BaseDSLMethods
       module HasFields
         include EmptyObjects
         # Add a field to this object or interface with the given definition
-        # @param name_positional [Symbol] The underscore-cased version of this field name (will be camelized for the GraphQL API); `name:` keyword is also accepted
-        # @param type_positional [Class, GraphQL::BaseType, Array] The return type of this field; `type:` keyword is also accepted
-        # @param desc_positional [String] Field description; `description:` keyword is also accepted
-        # @option kwargs [Symbol] :name The underscore-cased version of this field name (will be camelized for the GraphQL API); positional argument also accepted
-        # @option kwargs [Class, GraphQL::BaseType, Array] :type The return type of this field; positional argument is also accepted
-        # @option kwargs [Boolean] :null (defaults to `true`) `true` if this field may return `null`, `false` if it is never `null`
-        # @option kwargs [String] :description Field description; positional argument also accepted
-        # @option kwargs [String] :comment Field comment
-        # @option kwargs [String] :deprecation_reason If present, the field is marked "deprecated" with this message
-        # @option kwargs [Symbol] :method The method to call on the underlying object to resolve this field (defaults to `name`)
-        # @option kwargs [String, Symbol] :hash_key The hash key to lookup on the underlying object (if its a Hash) to resolve this field (defaults to `name` or `name.to_s`)
-        # @option kwargs [Array<String, Symbol>] :dig The nested hash keys to lookup on the underlying hash to resolve this field using dig
-        # @option kwargs [Symbol, true] :resolver_method The method on the type to call to resolve this field (defaults to `name`)
-        # @option kwargs [Symbol, true] :resolve_static Used by {Schema.execute_next} to produce a single value, shared by all objects which resolve this field. Called on the owner type class with `context, **arguments`
-        # @option kwargs [Symbol, true] :resolve_batch Used by {Schema.execute_next} map `objects` to a same-sized Array of results. Called on the owner type class with `objects, context, **arguments`.
-        # @option kwargs [Symbol, true] :resolve_each Used by {Schema.execute_next} to get a value value for each item. Called on the owner type class with `object, context, **arguments`.
-        # @option kwargs [Symbol, true] :resolve_legacy_instance_method Used by {Schema.execute_next} to get a value value for each item. Calls an instance method on the object type class.
-        # @option kwargs [Boolean] :connection `true` if this field should get automagic connection behavior; default is to infer by `*Connection` in the return type name
-        # @option kwargs [Class] :connection_extension The extension to add, to implement connections. If `nil`, no extension is added.
-        # @option kwargs [Integer, nil] :max_page_size For connections, the maximum number of items to return from this field, or `nil` to allow unlimited results.
-        # @option kwargs [Integer, nil] :default_page_size For connections, the default number of items to return from this field, or `nil` to return unlimited results.
-        # @option kwargs [Boolean] :introspection If true, this field will be marked as `#introspection?` and the name may begin with `__`
-        # @option kwargs [{String=>GraphQL::Schema::Argument, Hash}] :arguments Arguments for this field (may be added in the block, also)
-        # @option kwargs [Boolean] :camelize If true, the field name will be camelized when building the schema
-        # @option kwargs [Numeric] :complexity When provided, set the complexity for this field
-        # @option kwargs [Boolean] :scope If true, the return type's `.scope_items` method will be called on the return value
-        # @option kwargs [Symbol, String] :subscription_scope A key in `context` which will be used to scope subscription payloads
-        # @option kwargs [Array<Class, Hash<Class => Object>>] :extensions Named extensions to apply to this field (see also {#extension})
-        # @option kwargs [Hash{Class => Hash}] :directives Directives to apply to this field
-        # @option kwargs [Boolean] :trace If true, a {GraphQL::Tracing} tracer will measure this scalar field
-        # @option kwargs [Boolean] :broadcastable Whether or not this field can be distributed in subscription broadcasts
-        # @option kwargs [Language::Nodes::FieldDefinition, nil] :ast_node If this schema was parsed from definition, this AST node defined the field
-        # @option kwargs [Boolean] :method_conflict_warning If false, skip the warning if this field's method conflicts with a built-in method
-        # @option kwargs [Array<Hash>] :validates Configurations for validating this field
-        # @option kwargs [Object] :fallback_value A fallback value if the method is not defined
-        # @option kwargs [Class<GraphQL::Schema::Mutation>] :mutation
-        # @option kwargs [Class<GraphQL::Schema::Resolver>] :resolver
-        # @option kwargs [Class<GraphQL::Schema::Subscription>] :subscription
-        # @option kwargs [Boolean] :dynamic_introspection (Private, used by GraphQL-Ruby)
-        # @option kwargs [Boolean] :relay_node_field (Private, used by GraphQL-Ruby)
-        # @option kwargs [Boolean] :relay_nodes_field (Private, used by GraphQL-Ruby)
-        # @option kwargs [Class, Hash] :dataload Shorthand for dataloader lookups
-        # @option kwargs [Array<:ast_node, :parent, :lookahead, :owner, :execution_errors, :graphql_name, :argument_details, Symbol>] :extras Extra arguments to be injected into the resolver for this field
-        # @param kwargs [Hash] Keywords for defining the field. Any not documented here will be passed to your base field class where they must be handled.
-        # @param definition_block [Proc] an additional block for configuring the field. Receive the field as a block param, or, if no block params are defined, then the block is `instance_eval`'d on the new {Field}.
-        # @yieldparam field [GraphQL::Schema::Field] The newly-created field instance
-        # @yieldreturn [void]
-        # @return [GraphQL::Schema::Field]
+        #
+        # **Parameters**
+        #
+        # - `name_positional` (`Symbol`) — The underscore-cased version of this field name (will be camelized for the GraphQL API); `name:` keyword is also accepted
+        # - `type_positional` (`Class, GraphQL::BaseType, Array`) — The return type of this field; `type:` keyword is also accepted
+        # - `desc_positional` (`String`) — Field description; `description:` keyword is also accepted
+        # - `kwargs` (`Hash`) — Keywords for defining the field. Any not documented here will be passed to your base field class where they must be handled.
+        # - `definition_block` (`Proc`) — an additional block for configuring the field. Receive the field as a block param, or, if no block params are defined, then the block is `instance_eval`'d on the new [Field](rdoc-ref:Field).
+        #
+        # **Options**
+        #
+        # - `kwargs.:name` (`Symbol`) — The underscore-cased version of this field name (will be camelized for the GraphQL API); positional argument also accepted
+        # - `kwargs.:type` (`Class, GraphQL::BaseType, Array`) — The return type of this field; positional argument is also accepted
+        # - `kwargs.:null` (`Boolean`) — (defaults to `true`) `true` if this field may return `null`, `false` if it is never `null`
+        # - `kwargs.:description` (`String`) — Field description; positional argument also accepted
+        # - `kwargs.:comment` (`String`) — Field comment
+        # - `kwargs.:deprecation_reason` (`String`) — If present, the field is marked "deprecated" with this message
+        # - `kwargs.:method` (`Symbol`) — The method to call on the underlying object to resolve this field (defaults to `name`)
+        # - `kwargs.:hash_key` (`String, Symbol`) — The hash key to lookup on the underlying object (if its a Hash) to resolve this field (defaults to `name` or `name.to_s`)
+        # - `kwargs.:dig` (`Array<String, Symbol>`) — The nested hash keys to lookup on the underlying hash to resolve this field using dig
+        # - `kwargs.:resolver_method` (`Symbol, true`) — The method on the type to call to resolve this field (defaults to `name`)
+        # - `kwargs.:resolve_static` (`Symbol, true`) — Used by `Schema.execute_next` to produce a single value, shared by all objects which resolve this field. Called on the owner type class with `context, **arguments`
+        # - `kwargs.:resolve_batch` (`Symbol, true`) — Used by `Schema.execute_next` map `objects` to a same-sized Array of results. Called on the owner type class with `objects, context, **arguments`.
+        # - `kwargs.:resolve_each` (`Symbol, true`) — Used by `Schema.execute_next` to get a value value for each item. Called on the owner type class with `object, context, **arguments`.
+        # - `kwargs.:resolve_legacy_instance_method` (`Symbol, true`) — Used by `Schema.execute_next` to get a value value for each item. Calls an instance method on the object type class.
+        # - `kwargs.:connection` (`Boolean`) — `true` if this field should get automagic connection behavior; default is to infer by `*Connection` in the return type name
+        # - `kwargs.:connection_extension` (`Class`) — The extension to add, to implement connections. If `nil`, no extension is added.
+        # - `kwargs.:max_page_size` (`Integer, nil`) — For connections, the maximum number of items to return from this field, or `nil` to allow unlimited results.
+        # - `kwargs.:default_page_size` (`Integer, nil`) — For connections, the default number of items to return from this field, or `nil` to return unlimited results.
+        # - `kwargs.:introspection` (`Boolean`) — If true, this field will be marked as `#introspection?` and the name may begin with `__`
+        # - `kwargs.:arguments` (`{String=>GraphQL::Schema::Argument, Hash}`) — Arguments for this field (may be added in the block, also)
+        # - `kwargs.:camelize` (`Boolean`) — If true, the field name will be camelized when building the schema
+        # - `kwargs.:complexity` (`Numeric`) — When provided, set the complexity for this field
+        # - `kwargs.:scope` (`Boolean`) — If true, the return type's `.scope_items` method will be called on the return value
+        # - `kwargs.:subscription_scope` (`Symbol, String`) — A key in `context` which will be used to scope subscription payloads
+        # - `kwargs.:extensions` (`Array<Class, Hash<Class => Object>>`) — Named extensions to apply to this field (see also [Field#extension](rdoc-ref:GraphQL::Schema::Field#extension))
+        # - `kwargs.:directives` (`Hash{Class => Hash}`) — Directives to apply to this field
+        # - `kwargs.:trace` (`Boolean`) — If true, a [GraphQL::Tracing](rdoc-ref:GraphQL::Tracing) tracer will measure this scalar field
+        # - `kwargs.:broadcastable` (`Boolean`) — Whether or not this field can be distributed in subscription broadcasts
+        # - `kwargs.:ast_node` (`Language::Nodes::FieldDefinition, nil`) — If this schema was parsed from definition, this AST node defined the field
+        # - `kwargs.:method_conflict_warning` (`Boolean`) — If false, skip the warning if this field's method conflicts with a built-in method
+        # - `kwargs.:validates` (`Array<Hash>`) — Configurations for validating this field
+        # - `kwargs.:fallback_value` (`Object`) — A fallback value if the method is not defined
+        # - `kwargs.:mutation` (`Class<GraphQL::Schema::Mutation>`)
+        # - `kwargs.:resolver` (`Class<GraphQL::Schema::Resolver>`)
+        # - `kwargs.:subscription` (`Class<GraphQL::Schema::Subscription>`)
+        # - `kwargs.:dynamic_introspection` (`Boolean`) — (Private, used by GraphQL-Ruby)
+        # - `kwargs.:relay_node_field` (`Boolean`) — (Private, used by GraphQL-Ruby)
+        # - `kwargs.:relay_nodes_field` (`Boolean`) — (Private, used by GraphQL-Ruby)
+        # - `kwargs.:dataload` (`Class, Hash`) — Shorthand for dataloader lookups
+        # - `kwargs.:extras` (`Array<:ast_node, :parent, :lookahead, :owner, :execution_errors, :graphql_name, :argument_details, Symbol>`) — Extra arguments to be injected into the resolver for this field
+        #
+        # **Yields**
+        #
+        # - `field` (`GraphQL::Schema::Field`) — The newly-created field instance
+        # - `void`
+        #
+        # **Returns**
+        #
+        # - `GraphQL::Schema::Field`
+        #
+        # :call-seq:
+        #   field(Symbol name_positional, Class | GraphQL::BaseType | Array type_positional, String desc_positional, Hash **kwargs, Proc &definition_block) -> GraphQL::Schema::Field
         def field(name_positional = nil, type_positional = nil, desc_positional = nil, **kwargs, &definition_block)
           resolver = kwargs.delete(:resolver)
           mutation = kwargs.delete(:mutation)
@@ -93,23 +113,32 @@ module GraphQL
 
         # A list of Ruby keywords.
         #
-        # @api private
+        # :nodoc:
         RUBY_KEYWORDS = [:class, :module, :def, :undef, :begin, :rescue, :ensure, :end, :if, :unless, :then, :elsif, :else, :case, :when, :while, :until, :for, :break, :next, :redo, :retry, :in, :do, :return, :yield, :super, :self, :nil, :true, :false, :and, :or, :not, :alias, :defined?, :BEGIN, :END, :__LINE__, :__FILE__]
 
         # A list of GraphQL-Ruby keywords.
         #
-        # @api private
+        # :nodoc:
         GRAPHQL_RUBY_KEYWORDS = [:context, :object, :raw_value]
 
         # A list of field names that we should advise users to pick a different
         # resolve method name.
         #
-        # @api private
+        # :nodoc:
         CONFLICT_FIELD_NAMES = Set.new(GRAPHQL_RUBY_KEYWORDS + RUBY_KEYWORDS + Object.instance_methods)
 
         # Register this field with the class, overriding a previous one if needed.
-        # @param field_defn [GraphQL::Schema::Field]
-        # @return [void]
+        #
+        # **Parameters**
+        #
+        # - `field_defn` (`GraphQL::Schema::Field`)
+        #
+        # **Returns**
+        #
+        # - `void`
+        #
+        # :call-seq:
+        #   add_field(GraphQL::Schema::Field field_defn, method_conflict_warning:) -> void
         def add_field(field_defn, method_conflict_warning: field_defn.method_conflict_warning?)
           # Check that `field_defn.original_name` equals `resolver_method` and `method_sym` --
           # that shows that no override value was given manually.
@@ -137,7 +166,12 @@ module GraphQL
           nil
         end
 
-        # @return [Class] The class to initialize when adding fields to this kind of schema member
+        # **Returns**
+        #
+        # - `Class` — The class to initialize when adding fields to this kind of schema member
+        #
+        # :call-seq:
+        #   field_class(new_field_class) -> Class
         def field_class(new_field_class = nil)
           if new_field_class
             @field_class = new_field_class
@@ -152,6 +186,7 @@ module GraphQL
           type = self
           field field_name, "ID", **kwargs, null: false, resolve_each: true
           define_method(field_name) do
+            #: self as GraphQL::Schema::Object
             context.schema.id_from_object(object, type, context)
           end
 
@@ -160,26 +195,45 @@ module GraphQL
           end
         end
 
-        # @param new_has_no_fields [Boolean] Call with `true` to make this Object type ignore the requirement to have any defined fields.
-        # @return [void]
+        # **Parameters**
+        #
+        # - `new_has_no_fields` (`Boolean`) — Call with `true` to make this Object type ignore the requirement to have any defined fields.
+        #
+        # **Returns**
+        #
+        # - `void`
+        #
+        # :call-seq:
+        #   has_no_fields(bool new_has_no_fields) -> void
         def has_no_fields(new_has_no_fields)
           @has_no_fields = new_has_no_fields
           nil
         end
 
-        # @return [Boolean] `true` if `has_no_fields(true)` was configued
+        # **Returns**
+        #
+        # - `Boolean` — `true` if `has_no_fields(true)` was configued
+        #
+        # :call-seq:
+        #   has_no_fields?() -> bool
         def has_no_fields?
           @has_no_fields
         end
 
-        # @return [Hash<String => GraphQL::Schema::Field, Array<GraphQL::Schema::Field>>] Fields defined on this class _specifically_, not parent classes
+        # **Returns**
+        #
+        # - `Hash<String => GraphQL::Schema::Field, Array<GraphQL::Schema::Field>>` — Fields defined on this class _specifically_, not parent classes
+        #
+        # :call-seq:
+        #   own_fields() -> Hash[String, GraphQL::Schema::Field | Array[GraphQL::Schema::Field]]
         def own_fields
           @own_fields ||= {}
         end
 
         def all_field_definitions
           all_fields = {}
-          ancestors.reverse_each do |ancestor|
+          all_ancestors = ancestors #: Array[untyped]
+          all_ancestors.reverse_each do |ancestor|
             if ancestor.respond_to?(:own_fields)
               all_fields.merge!(ancestor.own_fields)
             end
@@ -189,11 +243,14 @@ module GraphQL
           all_fields
         end
 
+        #--
+        # @requires_ancestor: Module
         module InterfaceMethods
           def get_field(field_name, context = GraphQL::Query::NullContext.instance)
             warden = Warden.from_context(context)
             skip_visible = context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Visibility::Profile)
-            for ancestor in ancestors
+            all_ancestors = ancestors #: Array[untyped]
+            for ancestor in all_ancestors
               if ancestor.respond_to?(:own_fields) &&
                   (f_entry = ancestor.own_fields[field_name]) &&
                   (skip_visible || (f_entry = Warden.visible_entry?(:visible_field?, f_entry, context, warden)))
@@ -203,12 +260,18 @@ module GraphQL
             nil
           end
 
-          # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
+          # **Returns**
+          #
+          # - `Hash<String => GraphQL::Schema::Field>` — Fields on this object, keyed by name, including inherited fields
+          #
+          # :call-seq:
+          #   fields(context:) -> Hash[String, GraphQL::Schema::Field]
           def fields(context = GraphQL::Query::NullContext.instance)
             warden = Warden.from_context(context)
             # Local overrides take precedence over inherited fields
             visible_fields = {}
-            for ancestor in ancestors
+            all_ancestors = ancestors #: Array[untyped]
+            for ancestor in all_ancestors
               if ancestor.respond_to?(:own_fields)
                 ancestor.own_fields.each do |field_name, fields_entry|
                   # Choose the most local definition that passes `.visible?` --
@@ -223,11 +286,15 @@ module GraphQL
           end
         end
 
+        #--
+        # @requires_ancestor: Kernel
+        # @requires_ancestor: Module
+        # @requires_ancestor: GraphQL::Schema::Member::HasFields
         module ObjectMethods
           def get_field(field_name, context = GraphQL::Query::NullContext.instance)
             # Objects need to check that the interface implementation is visible, too
             warden = Warden.from_context(context)
-            ancs = ancestors
+            ancs = ancestors #: Array[untyped]
             skip_visible = context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Visibility::Profile)
             i = 0
             while (ancestor = ancs[i])
@@ -242,14 +309,20 @@ module GraphQL
             nil
           end
 
-          # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
+          # **Returns**
+          #
+          # - `Hash<String => GraphQL::Schema::Field>` — Fields on this object, keyed by name, including inherited fields
+          #
+          # :call-seq:
+          #   fields(context:) -> Hash[String, GraphQL::Schema::Field]
           def fields(context = GraphQL::Query::NullContext.instance)
             # Objects need to check that the interface implementation is visible, too
             warden = Warden.from_context(context)
             # Local overrides take precedence over inherited fields
             visible_fields = {}
-            had_any_fields_at_all = false
-            for ancestor in ancestors
+            had_any_fields_at_all = false #: bool
+            all_ancestors = ancestors #: Array[untyped]
+            for ancestor in all_ancestors
               if ancestor.respond_to?(:own_fields) && visible_interface_implementation?(ancestor, context, warden)
                 ancestor.own_fields.each do |field_name, fields_entry|
                   had_any_fields_at_all = true
@@ -293,8 +366,8 @@ module GraphQL
         # If `type` is an interface, and `self` has a type membership for `type`, then make sure it's visible.
         def visible_interface_implementation?(type, context, warden)
           if type.respond_to?(:kind) && type.kind.interface?
-            implements_this_interface = false
-            implementation_is_visible = false
+            implements_this_interface = false #: bool
+            implementation_is_visible = false #: bool
             warden.interface_type_memberships(self, context).each do |tm|
               if tm.abstract_type == type
                 implements_this_interface ||= true
@@ -313,8 +386,16 @@ module GraphQL
           end
         end
 
-        # @param field_defn [GraphQL::Schema::Field]
-        # @return [String] A warning to give when this field definition might conflict with a built-in method
+        # **Parameters**
+        #
+        # - `field_defn` (`GraphQL::Schema::Field`)
+        #
+        # **Returns**
+        #
+        # - `String` — A warning to give when this field definition might conflict with a built-in method
+        #
+        # :call-seq:
+        #   conflict_field_name_warning(GraphQL::Schema::Field field_defn) -> String
         def conflict_field_name_warning(field_defn)
           "#{self.graphql_name}'s `field :#{field_defn.original_name}` conflicts with a built-in method, use `resolver_method:` to pick a different resolver method for this field (for example, `resolver_method: :resolve_#{field_defn.resolver_method}` and `def resolve_#{field_defn.resolver_method}`). Or use `method_conflict_warning: false` to suppress this warning."
         end

data/lib/graphql/schema/member/has_interfaces.rb

@@ -1,16 +1,22 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
     class Member
+      #--
+      # @requires_ancestor: Kernel
+      # @requires_ancestor: Module
       module HasInterfaces
         def implements(*new_interfaces, **options)
           new_memberships = []
           new_interfaces.each do |int|
             if int.is_a?(Module)
               unless int.include?(GraphQL::Schema::Interface) && !int.is_a?(Class)
-                raise "#{int.respond_to?(:graphql_name) ? "#{int.graphql_name} (#{int})" : int.inspect} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
+                non_interface = int #: untyped
+                raise "#{non_interface.respond_to?(:graphql_name) ? "#{non_interface.graphql_name} (#{non_interface})" : non_interface.inspect} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
               end
+              int = int #: as GraphQL::Schema::Member::interface_definition
 
               new_memberships << int.type_membership_class.new(int, self, **options)
 
@@ -69,6 +75,8 @@ module GraphQL
             child_class.extend(InheritedInterfaces)
           end
 
+          #--
+          # @requires_ancestor: singleton(Object)
           module InheritedInterfaces
             def interfaces(context = GraphQL::Query::NullContext.instance)
               visible_interfaces = super
@@ -101,7 +109,7 @@ module GraphQL
         # param context [Query::Context] If omitted, skip filtering.
         def interfaces(context = GraphQL::Query::NullContext.instance)
           warden = Warden.from_context(context)
-          visible_interfaces = nil
+          visible_interfaces = nil #: Array[untyped]?
           own_interface_type_memberships.each do |type_membership|
             case type_membership
             when Schema::TypeMembership

data/lib/graphql/schema/member/has_path.rb

@@ -1,20 +1,29 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
     class Member
+      #--
+      # @requires_ancestor: Kernel
       module HasPath
-        # @return [String] A description of this member's place in the GraphQL schema
+        # **Returns**
+        #
+        # - `String` — A description of this member's place in the GraphQL schema
+        #
+        # :call-seq:
+        #   path() -> String
         def path
-          path_str = if self.respond_to?(:graphql_name)
-            self.graphql_name
+          member = self #: untyped
+          path_str = if member.respond_to?(:graphql_name)
+            member.graphql_name
           elsif self.class.respond_to?(:graphql_name)
             # Instances of resolvers
             self.class.graphql_name
           end
 
-          if self.respond_to?(:owner) && owner.respond_to?(:path)
-            path_str = "#{owner.path}.#{path_str}"
+          if member.respond_to?(:owner) && member.owner.respond_to?(:path)
+            path_str = "#{member.owner.path}.#{path_str}"
           end
 
           path_str

data/lib/graphql/schema/member/has_unresolved_type_error.rb

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

data/lib/graphql/schema/member/has_validators.rb

@@ -1,14 +1,24 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   class Schema
     class Member
       module HasValidators
         include GraphQL::EmptyObjects
 
-        # Build {GraphQL::Schema::Validator}s based on the given configuration
+        # Build [GraphQL::Schema::Validator](rdoc-ref:GraphQL::Schema::Validator)s based on the given configuration
         # and use them for this schema member
-        # @param validation_config [Hash{Symbol => Hash}]
-        # @return [void]
+        #
+        # **Parameters**
+        #
+        # - `validation_config` (`Hash{Symbol => Hash}`)
+        #
+        # **Returns**
+        #
+        # - `void`
+        #
+        # :call-seq:
+        #   validates(Hash[Symbol, Hash] validation_config) -> void
         def validates(validation_config)
           new_validators = GraphQL::Schema::Validator.from_config(self, validation_config)
           @own_validators ||= []
@@ -16,7 +26,12 @@ module GraphQL
           nil
         end
 
-        # @return [Array<GraphQL::Schema::Validator>]
+        # **Returns**
+        #
+        # - `Array<GraphQL::Schema::Validator>`
+        #
+        # :call-seq:
+        #   validators() -> Array[GraphQL::Schema::Validator]
         def validators
           @own_validators || EMPTY_ARRAY
         end

data/lib/graphql/schema/member/relay_shortcuts.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
     class Member
+      #--
+      # @requires_ancestor: Module
+      # @requires_ancestor: GraphQL::Schema::Member::BaseDSLMethods
       module RelayShortcuts
         def edge_type_class(new_edge_type_class = nil)
           if new_edge_type_class
@@ -12,7 +16,8 @@ module GraphQL
             # Don't call `ancestor.edge_type_class`
             # because we don't want a fallback from any ancestors --
             # only apply the fallback if _no_ ancestor has a configured value!
-            for ancestor in self.ancestors
+            all_ancestors = self.ancestors #: Array[untyped]
+            for ancestor in all_ancestors
               if ancestor.respond_to?(:configured_edge_type_class, true) && (etc = ancestor.configured_edge_type_class)
                 return etc
               end
@@ -29,7 +34,8 @@ module GraphQL
             # Don't call `ancestor.connection_type_class`
             # because we don't want a fallback from any ancestors --
             # only apply the fallback if _no_ ancestor has a configured value!
-            for ancestor in self.ancestors
+            all_ancestors = self.ancestors #: Array[untyped]
+            for ancestor in all_ancestors
               if ancestor.respond_to?(:configured_connection_type_class, true) && (ctc = ancestor.configured_connection_type_class)
                 return ctc
               end
@@ -44,6 +50,7 @@ module GraphQL
             edge_name = self.graphql_name + "Edge"
             node_type_class = self
             Class.new(edge_type_class) do
+              #: self as untyped
               graphql_name(edge_name)
               node_type(node_type_class)
             end
@@ -56,6 +63,7 @@ module GraphQL
             conn_name = self.graphql_name + "Connection"
             edge_type_class = self.edge_type
             Class.new(connection_type_class) do
+              #: self as untyped
               graphql_name(conn_name)
               edge_type(edge_type_class)
             end

data/lib/graphql/schema/member/scoped.rb

@@ -1,17 +1,28 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
     class Member
+      #--
+      # @requires_ancestor: GraphQL::Schema::FindInheritedValue
       module Scoped
         # This is called when a field has `scope: true`.
         # The field's return type class receives this call.
         #
         # By default, it's a no-op. Override it to scope your objects.
         #
-        # @param items [Object] Some list-like object (eg, Array, ActiveRecord::Relation)
-        # @param context [GraphQL::Query::Context]
-        # @return [Object] Another list-like object, scoped to the current context
+        # **Parameters**
+        #
+        # - `items` (`Object`) — Some list-like object (eg, Array, ActiveRecord::Relation)
+        # - `context` (`GraphQL::Query::Context`)
+        #
+        # **Returns**
+        #
+        # - `Object` — Another list-like object, scoped to the current context
+        #
+        # :call-seq:
+        #   scope_items(Object items, GraphQL::Query::Context context) -> Object
         def scope_items(items, context)
           items
         end