graphql 2.6.11 → 2.6.13

data/lib/graphql/schema/visibility.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 require "graphql/schema/visibility/profile"
 require "graphql/schema/visibility/migration"
 require "graphql/schema/visibility/visit"
@@ -14,10 +15,15 @@ module GraphQL
           super(message)
         end
       end
-      # @param schema [Class<GraphQL::Schema>]
-      # @param profiles [Hash<Symbol => Hash>] A hash of `name => context` pairs for preloading visibility profiles
-      # @param preload [Boolean] if `true`, load the default schema profile and all named profiles immediately (defaults to `true` for `Rails.env.production?` and `Rails.env.staging?`)
-      # @param migration_errors [Boolean] if `true`, raise an error when `Visibility` and `Warden` return different results
+      # **Parameters**
+      #
+      # - `schema` (`Class<GraphQL::Schema>`)
+      # - `profiles` (`Hash<Symbol => Hash>`) — A hash of `name => context` pairs for preloading visibility profiles
+      # - `preload` (`Boolean`) — if `true`, load the default schema profile and all named profiles immediately (defaults to `true` for `Rails.env.production?` and `Rails.env.staging?`)
+      # - `migration_errors` (`Boolean`) — if `true`, raise an error when `Visibility` and `Warden` return different results
+      #
+      # :call-seq:
+      #   use(Class[GraphQL::Schema] schema, dynamic:, Hash[Symbol, Hash] profiles:, bool preload:)
       def self.use(schema, dynamic: false, profiles: EmptyObjects::EMPTY_HASH, preload: (defined?(Rails.env) ? (Rails.env.production? || Rails.env.staging? || nil) : false), migration_errors: false)
         profiles&.each { |name, ctx|
           ctx[:visibility_profile] = name
@@ -108,35 +114,32 @@ module GraphQL
         end
       end
 
-      # @api private
-      def query_configured(query_type)
+      def query_configured(query_type) # :nodoc:
         require_if_preloaded("a query type was", "query(...)")
       end
 
-      # @api private
-      def mutation_configured(mutation_type)
+      def mutation_configured(mutation_type) # :nodoc:
         require_if_preloaded("a mutation type was", "mutation(...)")
       end
 
-      # @api private
-      def subscription_configured(subscription_type)
+      def subscription_configured(subscription_type) # :nodoc:
         require_if_preloaded("a mutation type was", "subscription(...)")
       end
 
-      # @api private
-      def orphan_types_configured(orphan_types)
+      def orphan_types_configured(orphan_types) # :nodoc:
         require_if_preloaded("orphan types were", "orphan_types(...)")
       end
 
-      # @api private
-      def introspection_system_configured(introspection_system)
+      def introspection_system_configured(introspection_system) # :nodoc:
         require_if_preloaded("custom introspection was", "introspection(...)")
       end
 
       # Make another Visibility for `schema` based on this one
-      # @return [Visibility]
-      # @api private
-      def dup_for(other_schema)
+      #
+      # **Returns**
+      #
+      # - `Visibility`
+      def dup_for(other_schema) # :nodoc:
         self.class.new(
           other_schema,
           dynamic: @dynamic,
@@ -179,8 +182,7 @@ module GraphQL
 
       attr_reader :top_level
 
-      # @api private
-      attr_reader :unfiltered_interface_type_memberships
+      attr_reader :unfiltered_interface_type_memberships # :nodoc:
 
       def top_level_profile(refresh: false)
         if refresh
@@ -231,6 +233,7 @@ module GraphQL
           @unions_for_references = Set.new
           @visit = Visibility::Visit.new(@schema) do |member|
             if member.is_a?(Module)
+              member = member #: as GraphQL::Schema::Member::type_definition
               type_name = member.graphql_name
               if (prev_t = @types[type_name])
                 if prev_t.is_a?(Array)
@@ -245,7 +248,8 @@ module GraphQL
               if member < GraphQL::Schema::Directive
                 @directives << member
               elsif member.respond_to?(:interface_type_memberships)
-                member.interface_type_memberships.each do |itm|
+                implementing_type = member #: as GraphQL::Schema::Member::HasInterfaces
+                implementing_type.interface_type_memberships.each do |itm|
                   @all_references[itm.abstract_type] << member
                   # `itm.object_type` may not actually be `member` if this implementation
                   # is inherited from a superclass

data/lib/graphql/schema/warden.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
+# typed: true
 
 require 'set'
 
 module GraphQL
   class Schema
-    # Restrict access to a {GraphQL::Schema} with a user-defined `visible?` implementations.
+    # Restrict access to a [GraphQL::Schema](rdoc-ref:GraphQL::Schema) with a user-defined `visible?` implementations.
     #
     # When validating and executing a query, all access to schema members
     # should go through a warden. If you access the schema directly,
     # you may show a client something that it shouldn't be allowed to see.
     #
-    # @api private
-    class Warden
+    class Warden # :nodoc:
       def self.from_context(context)
         context.warden || PassThruWarden
       rescue NoMethodError
@@ -30,15 +30,23 @@ module GraphQL
         # no-op
       end
 
-      # @param visibility_method [Symbol] a Warden method to call for this entry
-      # @param entry [Object, Array<Object>] One or more definitions for a given name in a GraphQL Schema
-      # @param context [GraphQL::Query::Context]
-      # @param warden [Warden]
-      # @return [Object] `entry` or one of `entry`'s items if exactly one of them is visible for this context
-      # @return [nil] If neither `entry` nor any of `entry`'s items are visible for this context
+      # **Parameters**
+      #
+      # - `visibility_method` (`Symbol`) — a Warden method to call for this entry
+      # - `entry` (`Object, Array<Object>`) — One or more definitions for a given name in a GraphQL Schema
+      # - `context` (`GraphQL::Query::Context`)
+      # - `warden` (`Warden`)
+      #
+      # **Returns**
+      #
+      # - `Object` — `entry` or one of `entry`'s items if exactly one of them is visible for this context
+      # - `nil` — If neither `entry` nor any of `entry`'s items are visible for this context
+      #
+      # :call-seq:
+      #   visible_entry?(Symbol visibility_method, Object | Array[Object] entry, GraphQL::Query::Context context, Warden warden) -> Object | nil
       def self.visible_entry?(visibility_method, entry, context, warden = Warden.from_context(context))
         if entry.is_a?(Array)
-          visible_item = nil
+          visible_item = nil #: untyped
           entry.each do |item|
             if warden.public_send(visibility_method, item, context)
               if visible_item.nil?
@@ -107,7 +115,7 @@ module GraphQL
         def get_field(parent_type, field_name); @schema.get_field(parent_type, field_name); end
         def reachable_type?(type_name); true; end
         def loadable?(type, _ctx); true; end
-        def loadable_possible_types(abstract_type, _ctx); union_type.possible_types; end
+        def loadable_possible_types(abstract_type, _ctx); possible_types(abstract_type); end
         def reachable_types; @schema.types.values; end # rubocop:disable Development/ContextIsPassedCop
         def possible_types(type_defn); @schema.possible_types(type_defn, Query::NullContext.instance, false); end
         def interfaces(obj_type); obj_type.interfaces; end
@@ -195,8 +203,13 @@ module GraphQL
         end
       end
 
-      # @param context [GraphQL::Query::Context]
-      # @param schema [GraphQL::Schema]
+      # **Parameters**
+      #
+      # - `context` (`GraphQL::Query::Context`)
+      # - `schema` (`GraphQL::Schema`)
+      #
+      # :call-seq:
+      #   initialize(GraphQL::Query::Context context:, GraphQL::Schema schema:)
       def initialize(context:, schema:)
         @schema = schema
         # Cache these to avoid repeated hits to the inheritance chain when one isn't present
@@ -217,7 +230,12 @@ module GraphQL
 
       attr_writer :skip_warning
 
-      # @return [Hash<String, GraphQL::BaseType>] Visible types in the schema
+      # **Returns**
+      #
+      # - `Hash<String, GraphQL::BaseType>` — Visible types in the schema
+      #
+      # :call-seq:
+      #   types() -> Hash[String, GraphQL::BaseType]
       def types
         @types ||= begin
           vis_types = {}
@@ -230,7 +248,12 @@ module GraphQL
         end
       end
 
-      # @return [Boolean] True if this type is used for `loads:` but not in the schema otherwise and not _explicitly_ hidden.
+      # **Returns**
+      #
+      # - `Boolean` — True if this type is used for `loads:` but not in the schema otherwise and not _explicitly_ hidden.
+      #
+      # :call-seq:
+      #   loadable?(type, _ctx) -> bool
       def loadable?(type, _ctx)
         visible_type?(type) &&
           !referenced?(type) &&
@@ -242,15 +265,21 @@ module GraphQL
       def loadable_possible_types(abstract_type, _ctx)
         @loadable_possible_types ||= read_through do |t|
           if t.is_a?(Class) # union
+            t = t #: as singleton(GraphQL::Schema::Union)
             t.possible_types
           else
-            @schema.possible_types(abstract_type)
+            @schema.possible_types(t)
           end
         end
         @loadable_possible_types[abstract_type]
       end
 
-      # @return [GraphQL::BaseType, nil] The type named `type_name`, if it exists (else `nil`)
+      # **Returns**
+      #
+      # - `GraphQL::BaseType, nil` — The type named `type_name`, if it exists (else `nil`)
+      #
+      # :call-seq:
+      #   get_type(type_name) -> GraphQL::BaseType | nil
       def get_type(type_name)
         @visible_types ||= read_through do |name|
           type_defn = @schema.get_type(name, @context, false)
@@ -264,18 +293,33 @@ module GraphQL
         @visible_types[type_name]
       end
 
-      # @return [Array<GraphQL::BaseType>] Visible and reachable types in the schema
+      # **Returns**
+      #
+      # - `Array<GraphQL::BaseType>` — Visible and reachable types in the schema
+      #
+      # :call-seq:
+      #   reachable_types() -> Array[GraphQL::BaseType]
       def reachable_types
         @reachable_types ||= reachable_type_set.to_a
       end
 
-      # @return Boolean True if the type is visible and reachable in the schema
+      # **Returns**
+      #
+      # - `Object` — Boolean True if the type is visible and reachable in the schema
+      #
+      # :call-seq:
+      #   reachable_type?(type_name) -> Object
       def reachable_type?(type_name)
         type = get_type(type_name) # rubocop:disable Development/ContextIsPassedCop -- `self` is query-aware
         type && reachable_type_set.include?(type)
       end
 
-      # @return [GraphQL::Field, nil] The field named `field_name` on `parent_type`, if it exists
+      # **Returns**
+      #
+      # - `GraphQL::Field, nil` — The field named `field_name` on `parent_type`, if it exists
+      #
+      # :call-seq:
+      #   get_field(parent_type, field_name) -> GraphQL::Field | nil
       def get_field(parent_type, field_name)
         @visible_parent_fields ||= read_through do |type|
           read_through do |f_name|
@@ -291,13 +335,23 @@ module GraphQL
         @visible_parent_fields[parent_type][field_name]
       end
 
-      # @return [GraphQL::Argument, nil] The argument named `argument_name` on `parent_type`, if it exists and is visible
+      # **Returns**
+      #
+      # - `GraphQL::Argument, nil` — The argument named `argument_name` on `parent_type`, if it exists and is visible
+      #
+      # :call-seq:
+      #   get_argument(parent_type, argument_name) -> GraphQL::Argument | nil
       def get_argument(parent_type, argument_name)
         argument = parent_type.get_argument(argument_name, @context)
         return argument if argument && visible_argument?(argument, @context)
       end
 
-      # @return [Array<GraphQL::BaseType>] The types which may be member of `type_defn`
+      # **Returns**
+      #
+      # - `Array<GraphQL::BaseType>` — The types which may be member of `type_defn`
+      #
+      # :call-seq:
+      #   possible_types(type_defn) -> Array[GraphQL::BaseType]
       def possible_types(type_defn)
         @visible_possible_types ||= read_through { |type_defn|
           pt = @schema.possible_types(type_defn, @context, false)
@@ -306,15 +360,31 @@ module GraphQL
         @visible_possible_types[type_defn]
       end
 
-      # @param type_defn [GraphQL::ObjectType, GraphQL::InterfaceType]
-      # @return [Array<GraphQL::Field>] Fields on `type_defn`
+      # **Parameters**
+      #
+      # - `type_defn` (`GraphQL::ObjectType, GraphQL::InterfaceType`)
+      #
+      # **Returns**
+      #
+      # - `Array<GraphQL::Field>` — Fields on `type_defn`
+      #
+      # :call-seq:
+      #   fields(GraphQL::ObjectType | GraphQL::InterfaceType type_defn) -> Array[GraphQL::Field]
       def fields(type_defn)
         @visible_fields ||= read_through { |t| @schema.get_fields(t, @context).values }
         @visible_fields[type_defn]
       end
 
-      # @param argument_owner [GraphQL::Field, GraphQL::InputObjectType]
-      # @return [Array<GraphQL::Argument>] Visible arguments on `argument_owner`
+      # **Parameters**
+      #
+      # - `argument_owner` (`GraphQL::Field, GraphQL::InputObjectType`)
+      #
+      # **Returns**
+      #
+      # - `Array<GraphQL::Argument>` — Visible arguments on `argument_owner`
+      #
+      # :call-seq:
+      #   arguments(GraphQL::Field | GraphQL::InputObjectType argument_owner, ctx) -> Array[GraphQL::Argument]
       def arguments(argument_owner, ctx = nil)
         @visible_arguments ||= read_through { |o|
           args = o.arguments(@context)
@@ -329,7 +399,12 @@ module GraphQL
         @visible_arguments[argument_owner]
       end
 
-      # @return [Array<GraphQL::EnumType::EnumValue>] Visible members of `enum_defn`
+      # **Returns**
+      #
+      # - `Array<GraphQL::EnumType::EnumValue>` — Visible members of `enum_defn`
+      #
+      # :call-seq:
+      #   enum_values(enum_defn) -> Array[GraphQL::EnumType::EnumValue]
       def enum_values(enum_defn)
         @visible_enum_arrays ||= read_through { |e|
           values = e.enum_values(@context)
@@ -346,7 +421,12 @@ module GraphQL
         @visible_enum_values[enum_value]
       end
 
-      # @return [Array<GraphQL::InterfaceType>] Visible interfaces implemented by `obj_type`
+      # **Returns**
+      #
+      # - `Array<GraphQL::InterfaceType>` — Visible interfaces implemented by `obj_type`
+      #
+      # :call-seq:
+      #   interfaces(obj_type) -> Array[GraphQL::InterfaceType]
       def interfaces(obj_type)
         @visible_interfaces ||= read_through { |t|
           ints = t.interfaces(@context)
@@ -371,7 +451,12 @@ module GraphQL
         end
       end
 
-      # @param owner [Class, Module] If provided, confirm that field has the given owner.
+      # **Parameters**
+      #
+      # - `owner` (`Class, Module`) — If provided, confirm that field has the given owner.
+      #
+      # :call-seq:
+      #   visible_field?(field_defn, _ctx, Class | Module owner)
       def visible_field?(field_defn, _ctx = nil, owner = field_defn.owner)
         # This field is visible in its own right
         visible?(field_defn) &&
@@ -453,8 +538,8 @@ module GraphQL
       # (If it _wasn't_ inherited, then don't hide it for this reason.)
       def field_on_visible_interface?(field_defn, type_defn)
         if type_defn.kind.object?
-          any_interface_has_field = false
-          any_interface_has_visible_field = false
+          any_interface_has_field = false #: bool
+          any_interface_has_visible_field = false #: bool
           ints = unfiltered_interfaces(type_defn)
           ints.each do |interface_type|
             if (iface_field_defn = interface_type.get_field(field_defn.graphql_name, @context))
@@ -510,6 +595,7 @@ module GraphQL
           member_type = case member
           when Module
             if member.respond_to?(:kind)
+              member = member #: as GraphQL::Schema::Member::type_definition
               member.kind.name.downcase
             else
               ""

data/lib/graphql/schema/wrapper.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
     class Wrapper
       include GraphQL::Schema::Member::TypeSystemHelpers
 
-      # @return [Class, Module] The inner type of this wrapping type, the type of which one or more objects may be present.
+      # **Returns**
+      #
+      # - `Class, Module` — The inner type of this wrapping type, the type of which one or more objects may be present.
       attr_reader :of_type
 
       def initialize(of_type)