graphql 2.6.12 → 2.6.14

data/lib/graphql/rake_task.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 require "fileutils"
 require "rake"
 require "graphql/rake_task/validate"
@@ -11,21 +12,32 @@ module GraphQL
   #
   # Use `load_context:` and `visible?` to dump schemas under certain visibility constraints.
   #
-  # @example Dump a Schema to .graphql + .json files
-  #   require "graphql/rake_task"
-  #   GraphQL::RakeTask.new(schema_name: "MySchema")
+  # **Examples**
   #
-  #   # $ rake graphql:schema:dump
-  #   # Schema IDL dumped to ./schema.graphql
-  #   # Schema JSON dumped to ./schema.json
+  # **Example: Dump a Schema to .graphql + .json files**
   #
-  # @example Invoking the task from Ruby
-  #   require "rake"
-  #   Rake::Task["graphql:schema:dump"].invoke
+  # ```ruby
+  # require "graphql/rake_task"
+  # GraphQL::RakeTask.new(schema_name: "MySchema")
   #
-  # @example Providing arguments to build the introspection query
-  #   require "graphql/rake_task"
-  #   GraphQL::RakeTask.new(schema_name: "MySchema", include_is_one_of: true)
+  # # $ rake graphql:schema:dump
+  # # Schema IDL dumped to ./schema.graphql
+  # # Schema JSON dumped to ./schema.json
+  # ```
+  #
+  # **Example: Invoking the task from Ruby**
+  #
+  # ```ruby
+  # require "rake"
+  # Rake::Task["graphql:schema:dump"].invoke
+  # ```
+  #
+  # **Example: Providing arguments to build the introspection query**
+  #
+  # ```ruby
+  # require "graphql/rake_task"
+  # GraphQL::RakeTask.new(schema_name: "MySchema", include_is_one_of: true)
+  # ```
   class RakeTask
     include Rake::DSL
 
@@ -45,37 +57,57 @@ module GraphQL
       include_is_one_of: false
     }
 
-    # @return [String] Namespace for generated tasks
+    # **Returns**
+    #
+    # - `String` — Namespace for generated tasks
     attr_writer :namespace
 
     def rake_namespace
       @namespace
     end
 
-    # @return [Array<String>]
+    # **Returns**
+    #
+    # - `Array<String>`
     attr_accessor :dependencies
 
-    # @return [String] By default, used to find the schema as a constant.
-    # @see {#load_schema} for loading a schema another way
+    # See [load_schema](rdoc-ref:#load_schema) for loading a schema another way
+    #
+    # **Returns**
+    #
+    # - `String` — By default, used to find the schema as a constant.
     attr_accessor :schema_name
 
-    # @return [<#call(task)>] A proc for loading the target GraphQL schema
+    # **Returns**
+    #
+    # - `<#call(task)>` — A proc for loading the target GraphQL schema
     attr_accessor :load_schema
 
-    # @return [<#call(task)>] A callable for loading the query context
+    # **Returns**
+    #
+    # - `<#call(task)>` — A callable for loading the query context
     attr_accessor :load_context
 
-    # @return [String] target for IDL task
+    # **Returns**
+    #
+    # - `String` — target for IDL task
     attr_accessor :idl_outfile
 
-    # @return [String] target for JSON task
+    # **Returns**
+    #
+    # - `String` — target for JSON task
     attr_accessor :json_outfile
 
-    # @return [String] directory for IDL & JSON files
+    # **Returns**
+    #
+    # - `String` — directory for IDL & JSON files
     attr_accessor :directory
 
-    # @return [Boolean] Options for additional fields in the introspection query JSON response
-    # @see GraphQL::Schema.as_json
+    # See [GraphQL::Schema.as_json](rdoc-ref:GraphQL::Schema.as_json).
+    #
+    # **Returns**
+    #
+    # - `Boolean` — Options for additional fields in the introspection query JSON response
     attr_accessor :include_deprecated_args, :include_schema_description, :include_is_repeatable, :include_specified_by_url, :include_is_one_of
 
     # Set the parameters of this task by passing keyword arguments

data/lib/graphql/relay/range_add.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   module Relay
     # This provides some isolation from `GraphQL::Relay` internals.
@@ -8,32 +9,42 @@ module GraphQL
     # The connection doesn't receive outside arguments, so the list of items
     # should be ordered and paginated before providing it here.
     #
-    # @example Adding a comment to list of comments
-    #   post = Post.find(args[:post_id])
-    #   comments = post.comments
-    #   new_comment = comments.build(body: args[:body])
-    #   new_comment.save!
+    # **Examples**
     #
-    #   range_add = GraphQL::Relay::RangeAdd.new(
-    #     parent: post,
-    #     collection: comments,
-    #     item: new_comment,
-    #     context: context,
-    #   )
+    # **Example: Adding a comment to list of comments**
     #
-    #   response = {
-    #     post: post,
-    #     comments_connection: range_add.connection,
-    #     new_comment_edge: range_add.edge,
-    #   }
+    # ```ruby
+    # post = Post.find(args[:post_id])
+    # comments = post.comments
+    # new_comment = comments.build(body: args[:body])
+    # new_comment.save!
+    #
+    # range_add = GraphQL::Relay::RangeAdd.new(
+    #   parent: post,
+    #   collection: comments,
+    #   item: new_comment,
+    #   context: context,
+    # )
+    #
+    # response = {
+    #   post: post,
+    #   comments_connection: range_add.connection,
+    #   new_comment_edge: range_add.edge,
+    # }
+    # ```
     class RangeAdd
       attr_reader :edge, :connection, :parent
 
-      # @param collection [Object] The list of items to wrap in a connection
-      # @param item [Object] The newly-added item (will be wrapped in `edge_class`)
-      # @param context [GraphQL::Query::Context] The surrounding `ctx`, will be passed to the connection
-      # @param parent [Object] The owner of `collection`, will be passed to the connection if provided
-      # @param edge_class [Class] The class to wrap `item` with (defaults to the connection's edge class)
+      # **Parameters**
+      #
+      # - `collection` (`Object`) — The list of items to wrap in a connection
+      # - `item` (`Object`) — The newly-added item (will be wrapped in `edge_class`)
+      # - `context` (`GraphQL::Query::Context`) — The surrounding `ctx`, will be passed to the connection
+      # - `parent` (`Object`) — The owner of `collection`, will be passed to the connection if provided
+      # - `edge_class` (`Class`) — The class to wrap `item` with (defaults to the connection's edge class)
+      #
+      # :call-seq:
+      #   initialize(Object collection:, Object item:, GraphQL::Query::Context context:, Object parent:, Class edge_class:)
       def initialize(collection:, item:, context:, parent: nil, edge_class: nil)
         conn_class = context.schema.connections.wrapper_for(collection)
         # The rest will be added by ConnectionExtension

data/lib/graphql/relay.rb

@@ -1,3 +1,4 @@
 # frozen_string_literal: true
+# typed: true
 
 require 'graphql/relay/range_add'

data/lib/graphql/rubocop/graphql/base_cop.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 require "rubocop"
 
 module GraphQL

data/lib/graphql/rubocop/graphql/default_null_true.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 require_relative "base_cop"
 
 module GraphQL
@@ -11,15 +12,17 @@ module GraphQL
       # to non-null fields (`null: false`) without a breaking change. (The opposite change, from `null: false`
       # to `null: true`, change.)
       #
-      # @example
-      #   # Both of these define `name: String` in GraphQL:
+      # **Examples**
       #
-      #   # bad
-      #   field :name, String, null: true
+      # **Example: # Both of these define `name: String` in GraphQL:**
       #
-      #   # good
-      #   field :name, String
+      # ```ruby
+      # # bad
+      # field :name, String, null: true
       #
+      # # good
+      # field :name, String
+      # ```
       class DefaultNullTrue < BaseCop
         MSG = "`null: true` is the default and can be removed."
 

data/lib/graphql/rubocop/graphql/default_required_true.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 require_relative "./base_cop"
 
 module GraphQL
@@ -11,15 +12,17 @@ module GraphQL
       # to optional arguments (`required: false`) without a breaking change. (The opposite change, from `required: false`
       # to `required: true`, change.)
       #
-      # @example
-      #   # Both of these define `id: ID!` in GraphQL:
+      # **Examples**
       #
-      #   # bad
-      #   argument :id, ID, required: true
+      # **Example: # Both of these define `id: ID!` in GraphQL:**
       #
-      #   # good
-      #   argument :id, ID
+      # ```ruby
+      # # bad
+      # argument :id, ID, required: true
       #
+      # # good
+      # argument :id, ID
+      # ```
       class DefaultRequiredTrue < BaseCop
         MSG = "`required: true` is the default and can be removed."
 

data/lib/graphql/rubocop/graphql/field_type_in_block.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 require_relative "./base_cop"
 
 module GraphQL
@@ -7,15 +8,18 @@ module GraphQL
       # Identify (and auto-correct) any field whose type configuration isn't given
       # in the configuration block.
       #
-      # @example
-      #   # bad, immediately causes Rails to load `app/graphql/types/thing.rb`
-      #   field :thing, Types::Thing
+      # **Examples**
       #
-      #   # good, defers loading until the file is needed
-      #   field :thing do
-      #     type(Types::Thing)
-      #   end
+      # **Example: # bad, immediately causes Rails to load `app/graphql/types/thing.rb`**
       #
+      # ```ruby
+      # field :thing, Types::Thing
+      #
+      # # good, defers loading until the file is needed
+      # field :thing do
+      #   type(Types::Thing)
+      # end
+      # ```
       class FieldTypeInBlock < BaseCop
         MSG = "type configuration can be moved to a block to defer loading the type's file"
 
@@ -133,7 +137,7 @@ module GraphQL
             field_indent << " "
             indent_test_idx -= 1
             if indent_test_idx == 0
-              raise "Invariant: somehow backtracted to beginning of class when looking for field indent (source: #{node_source.inspect})"
+              raise "Invariant: somehow backtracted to beginning of class when looking for field indent (source: #{type_defn_source.inspect})"
             end
           end
           field_indent

data/lib/graphql/rubocop/graphql/root_types_in_block.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 require_relative "./base_cop"
 
 module GraphQL
@@ -6,13 +7,16 @@ module GraphQL
     module GraphQL
       # Identify (and auto-correct) any root types in your schema file.
       #
-      # @example
-      #   # bad, immediately causes Rails to load `app/graphql/types/query.rb`
-      #   query Types::Query
+      # **Examples**
       #
-      #   # good, defers loading until the file is needed
-      #   query { Types::Query }
+      # **Example: # bad, immediately causes Rails to load `app/graphql/types/query.rb`**
       #
+      # ```ruby
+      # query Types::Query
+      #
+      # # good, defers loading until the file is needed
+      # query { Types::Query }
+      # ```
       class RootTypesInBlock < BaseCop
         MSG = "type configuration can be moved to a block to defer loading the type's file"
 

data/lib/graphql/rubocop.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 require "graphql/rubocop/graphql/default_null_true"
 require "graphql/rubocop/graphql/default_required_true"

data/lib/graphql/runtime_error.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   class RuntimeError < Error
     include GraphQL::Execution::Finalizer

data/lib/graphql/runtime_type_error.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   class RuntimeTypeError < GraphQL::Error
   end

data/lib/graphql/schema/addition.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
@@ -10,9 +11,10 @@ module GraphQL
         @own_types = own_types
         @directives = Set.new
         @possible_types = {}
+        @possible_types_sets = {}
         @types = {}
         @union_memberships = {}
-        @references = Hash.new { |h, k| h[k] = Set.new }
+        @references = {}.compare_by_identity
         @arguments_with_default_values = []
         add_type_and_traverse(new_types)
       end
@@ -20,7 +22,8 @@ module GraphQL
       private
 
       def references_to(thing, from:)
-        @references[thing].add(from)
+        refs = @references[thing] ||= {}.compare_by_identity
+        refs[from] = true
       end
 
       def get_type(name)
@@ -41,19 +44,25 @@ module GraphQL
 
       def add_directives_from(owner)
         if !(dir_instances = owner.directives).empty?
-          dirs = dir_instances.map(&:class)
-          @directives.merge(dirs)
-          add_type_and_traverse(dirs)
+          new_dirs = nil #: Array[singleton(GraphQL::Schema::Directive)]?
+          dir_instances.each do |dir|
+            dir_class = dir.class
+            if !@directives.include?(dir_class)
+              new_dirs ||= []
+              new_dirs << dir_class
+            end
+          end
+          if new_dirs
+            @directives.merge(new_dirs)
+            add_type_and_traverse(new_dirs)
+          end
         end
       end
 
       def add_type_and_traverse(new_types)
         late_types = []
-        path = []
         new_types.each do |t|
-          path.push(t.graphql_name)
-          add_type(t, owner: nil, late_types: late_types, path: path)
-          path.pop
+          add_type(t, owner: nil, late_types: late_types)
         end
         missed_late_types = 0
         while (late_type_vals = late_types.shift)
@@ -63,13 +72,13 @@ module GraphQL
             # Reset the counter, since we might succeed next go-round
             missed_late_types = 0
             update_type_owner(type_owner, type)
-            add_type(type, owner: type_owner, late_types: late_types, path: [type.graphql_name])
+            add_type(type, owner: type_owner, late_types: late_types)
           elsif lt.is_a?(LateBoundType)
             if (type = get_type(lt.name))
               # Reset the counter, since we might succeed next go-round
               missed_late_types = 0
               update_type_owner(type_owner, type)
-              add_type(type, owner: type_owner, late_types: late_types, path: [type.graphql_name])
+              add_type(type, owner: type_owner, late_types: late_types)
             else
               missed_late_types += 1
               # Add it back to the list, maybe we'll be able to resolve it later.
@@ -88,17 +97,29 @@ module GraphQL
         nil
       end
 
+      # The Set makes this fast for interfaces with many possible types. The Array keeps their order.
+      def add_possible_type(interface_type, object_type)
+        types_set = @possible_types_sets[interface_type] ||= Set.new
+        if types_set.add?(object_type)
+          pt = @possible_types[interface_type] ||= []
+          pt << object_type
+        end
+      end
+
       def update_type_owner(owner, type)
         case owner
         when Module
+          owner = owner #: as GraphQL::Schema::Member::type_definition
           if owner.kind.union?
+            union_type = owner #: as singleton(GraphQL::Schema::Union)
             # It's a union with possible_types
             # Replace the item by class name
-            owner.assign_type_membership_object_type(type)
-            @possible_types[owner] = owner.possible_types
+            union_type.assign_type_membership_object_type(type)
+            @possible_types[owner] = union_type.possible_types
           elsif type.kind.interface? && (owner.kind.object? || owner.kind.interface?)
+            implementing_type = owner #: as GraphQL::Schema::Member::HasInterfaces
             new_interfaces = []
-            owner.interfaces.each do |int_t|
+            implementing_type.interfaces.each do |int_t|
               if int_t.is_a?(String) && int_t == type.graphql_name
                 new_interfaces << type
               elsif int_t.is_a?(LateBoundType) && int_t.graphql_name == type.graphql_name
@@ -108,15 +129,19 @@ module GraphQL
                 # they were probably already added, maybe with options.
               end
             end
-            owner.implements(*new_interfaces)
+            implementing_type.implements(*new_interfaces)
             new_interfaces.each do |int|
-              pt = @possible_types[int] ||= []
-              if !pt.include?(owner) && owner.is_a?(Class)
-                pt << owner
+              if owner.is_a?(Class)
+                add_possible_type(int, owner)
               end
               int.interfaces.each do |indirect_int|
-                if indirect_int.is_a?(LateBoundType) && (indirect_int_type = get_type(indirect_int.graphql_name))
-                  update_type_owner(owner, indirect_int_type)
+                if indirect_int.is_a?(LateBoundType)
+                  if (indirect_int_type = get_type(indirect_int.graphql_name))
+                    update_type_owner(owner, indirect_int_type)
+                  end
+                elsif owner.is_a?(Class)
+                  # `implements` added this one, too, because `int` implements it
+                  add_possible_type(indirect_int, owner)
                 end
               end
             end
@@ -149,7 +174,7 @@ module GraphQL
         end
       end
 
-      def add_type(type, owner:, late_types:, path:)
+      def add_type(type, owner:, late_types:)
         if type.is_a?(String) || type.is_a?(GraphQL::Schema::LateBoundType)
           late_types << [owner, type]
           return
@@ -169,9 +194,7 @@ module GraphQL
             if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
               references_to(arg_type, from: arg)
             end
-            path.push(arg.graphql_name)
-            add_type(arg_type, owner: arg, late_types: late_types, path: path)
-            path.pop
+            add_type(arg_type, owner: arg, late_types: late_types)
             if arg.default_value?
               @arguments_with_default_values << arg
             end
@@ -190,40 +213,45 @@ module GraphQL
           if type.kind.fields?
             type.all_field_definitions.each do |field|
               field.ensure_loaded
-              name = field.graphql_name
               field_type = field.type.unwrap
-              if !field_type.is_a?(GraphQL::Schema::LateBoundType)
+              if field_type.is_a?(GraphQL::Schema::LateBoundType)
+                add_type(field_type, owner: field, late_types: late_types)
+              else
                 references_to(field_type, from: field)
+                if !@types[field_type.graphql_name].equal?(field_type)
+                  add_type(field_type, owner: field, late_types: late_types)
+                end
               end
-              path.push(name)
-              add_type(field_type, owner: field, late_types: late_types, path: path)
               add_directives_from(field)
               field.all_argument_definitions.each do |arg|
                 add_directives_from(arg)
                 arg_type = arg.type.unwrap
-                if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+                if arg_type.is_a?(GraphQL::Schema::LateBoundType)
+                  add_type(arg_type, owner: arg, late_types: late_types)
+                else
                   references_to(arg_type, from: arg)
+                  if !@types[arg_type.graphql_name].equal?(arg_type)
+                    add_type(arg_type, owner: arg, late_types: late_types)
+                  end
                 end
-                path.push(arg.graphql_name)
-                add_type(arg_type, owner: arg, late_types: late_types, path: path)
-                path.pop
                 if arg.default_value?
                   @arguments_with_default_values << arg
                 end
               end
-              path.pop
             end
           end
           if type.kind.input_object?
             type.all_argument_definitions.each do |arg|
               add_directives_from(arg)
               arg_type = arg.type.unwrap
-              if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+              if arg_type.is_a?(GraphQL::Schema::LateBoundType)
+                add_type(arg_type, owner: arg, late_types: late_types)
+              else
                 references_to(arg_type, from: arg)
+                if !@types[arg_type.graphql_name].equal?(arg_type)
+                  add_type(arg_type, owner: arg, late_types: late_types)
+                end
               end
-              path.push(arg.graphql_name)
-              add_type(arg_type, owner: arg, late_types: late_types, path: path)
-              path.pop
               if arg.default_value?
                 @arguments_with_default_values << arg
               end
@@ -231,18 +259,14 @@ module GraphQL
           end
           if type.kind.union?
             @possible_types[type] = type.all_possible_types
-            path.push("possible_types")
             type.all_possible_types.each do |t|
-              add_type(t, owner: type, late_types: late_types, path: path)
+              add_type(t, owner: type, late_types: late_types)
             end
-            path.pop
           end
           if type.kind.interface?
-            path.push("orphan_types")
             type.orphan_types.each do |t|
-              add_type(t, owner: type, late_types: late_types, path: path)
+              add_type(t, owner: type, late_types: late_types)
             end
-            path.pop
           end
           if type.kind.object?
             possible_types_for_this_name = @possible_types[type] ||= []
@@ -250,26 +274,21 @@ module GraphQL
           end
 
           if type.kind.object? || type.kind.interface?
-            path.push("implements")
             type.interface_type_memberships.each do |interface_type_membership|
               case interface_type_membership
               when Schema::TypeMembership
                 interface_type = interface_type_membership.abstract_type
                 # We can get these now; we'll have to get late-bound types later
                 if interface_type.is_a?(Module) && type.is_a?(Class)
-                  implementers = @possible_types[interface_type] ||= []
-                  if !implementers.include?(type)
-                    implementers << type
-                  end
+                  add_possible_type(interface_type, type)
                 end
               when String, Schema::LateBoundType
                 interface_type = interface_type_membership
               else
                 raise ArgumentError, "Invariant: unexpected type membership for #{type.graphql_name}: #{interface_type_membership.class} (#{interface_type_membership.inspect})"
               end
-              add_type(interface_type, owner: type, late_types: late_types, path: path)
+              add_type(interface_type, owner: type, late_types: late_types)
             end
-            path.pop
           end
 
           if type.kind.enum?

data/lib/graphql/schema/always_visible.rb

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