graphql 2.6.14 → 2.6.15

data/lib/graphql/static_validation/base_visitor.rb

@@ -1,26 +1,28 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     class BaseVisitor < GraphQL::Language::StaticVisitor
+      #: (GraphQL::Language::Nodes::Document document, GraphQL::StaticValidation::ValidationContext context) -> void
       def initialize(document, context)
-        @path = []
-        @path_depth = 0
-        @current_object_type = nil
-        @parent_object_type = nil
-        @current_field_definition = nil
-        @current_argument_definition = nil
-        @parent_argument_definition = nil
-        @current_directive_definition = nil
-        @context = context
-        @types = context.query.types
-        @schema = context.schema
-        @inline_fragment_paths = {}
-        @field_unwrapped_types = {}.compare_by_identity
-        @child_positions = {}.compare_by_identity
+        @path = [] #: Array[String | Integer]
+        @path_depth = 0 #: Integer
+        @current_object_type = nil #: GraphQL::Schema::Member::type_definition?
+        @parent_object_type = nil #: GraphQL::Schema::Member::type_definition?
+        @current_field_definition = nil #: GraphQL::Schema::Field?
+        @current_argument_definition = nil #: GraphQL::Schema::Argument?
+        @parent_argument_definition = nil #: GraphQL::Schema::Argument?
+        @current_directive_definition = nil #: singleton(GraphQL::Schema::Directive)?
+        @context = context #: GraphQL::StaticValidation::ValidationContext
+        @types = context.types #: GraphQL::Schema::Visibility::Profile | GraphQL::Schema::Warden::VisibilityProfile
+        @schema = context.schema #: singleton(GraphQL::Schema)
+        @inline_fragment_paths = {} #: Hash[String, String]
+        @field_unwrapped_types = {}.compare_by_identity #: Hash[GraphQL::Schema::Field, GraphQL::Schema::Member::type_definition]
+        @child_positions = {}.compare_by_identity #: Hash[GraphQL::Language::Nodes::AbstractNode, Hash[GraphQL::Language::Nodes::AbstractNode, Integer]]
         super(document)
       end
 
+      #: GraphQL::StaticValidation::ValidationContext
       attr_reader :context
 
       # **Returns**
@@ -29,8 +31,9 @@ module GraphQL
       #
       # :call-seq:
       #   path() -> Array[String]
+      #: () -> Array[String | Integer]
       def path
-        @path[0, @path_depth]
+        @path[0, @path_depth] #: as !nil
       end
 
       # Build a class to visit the AST and perform validation,
@@ -46,6 +49,7 @@ module GraphQL
       #
       # :call-seq:
       #   including_rules(Array[Module | Class] rules) -> Class
+      #: (Array[Module[untyped]]) -> singleton(GraphQL::StaticValidation::BaseVisitor)
       def self.including_rules(rules)
         if rules.empty?
           # It's not doing _anything?!?_
@@ -69,48 +73,71 @@ module GraphQL
         end
       end
 
+      #--
+      # @requires_ancestor: GraphQL::StaticValidation::BaseVisitor
       module ContextMethods
+        # BaseVisitor#initialize sets these. They're re-assigned here so Sorbet knows their types in this module,
+        # because the hooks below use them directly instead of calling the readers on every node.
+        #: (GraphQL::Language::Nodes::Document document, GraphQL::StaticValidation::ValidationContext context) -> void
+        def initialize(document, context)
+          super
+          @path = path_parts #: Array[String | Integer]
+          @path_depth = path_depth #: Integer
+          @types = types #: GraphQL::Schema::Visibility::Profile | GraphQL::Schema::Warden::VisibilityProfile
+          @inline_fragment_paths = inline_fragment_paths #: Hash[String, String]
+          @field_unwrapped_types = field_unwrapped_types #: Hash[GraphQL::Schema::Field, GraphQL::Schema::Member::type_definition]
+          @child_positions = child_positions_by_parent #: Hash[GraphQL::Language::Nodes::AbstractNode, Hash[GraphQL::Language::Nodes::AbstractNode, Integer]]
+        end
+
+        #: (GraphQL::Language::Nodes::OperationDefinition node, GraphQL::Language::Nodes::AbstractNode? parent) -> void
         def on_operation_definition(node, parent)
-          object_type = @schema.root_type_for_operation(node.operation_type)
+          object_type = schema.root_type_for_operation(node.operation_type)
           prev_parent_ot = @parent_object_type
-          @parent_object_type = @current_object_type
-          @current_object_type = object_type
-          @path[@path_depth] = "#{node.operation_type}#{node.name ? " #{node.name}" : ""}"
-          @path_depth += 1
+          @parent_object_type = @current_object_type #: GraphQL::Schema::Member::type_definition?
+          @current_object_type = object_type #: GraphQL::Schema::Member::type_definition?
+          path_depth = @path_depth
+          @path[path_depth] = "#{node.operation_type}#{node.name ? " #{node.name}" : ""}"
+          @path_depth = path_depth + 1
           super
           @current_object_type = @parent_object_type
           @parent_object_type = prev_parent_ot
-          @path_depth -= 1
+          @path_depth = path_depth
         end
 
+        #: (GraphQL::Language::Nodes::FragmentDefinition node, GraphQL::Language::Nodes::AbstractNode? parent) -> void
         def on_fragment_definition(node, parent)
-          object_type = if node.type
-            @types.type(node.type.name)
+          # The type is always present when parsed, but may be missing on a hand-built node:
+          fragment_type = node.type #: GraphQL::Language::Nodes::TypeName?
+          object_type = if fragment_type
+            @types.type(fragment_type.name)
           else
             @current_object_type
           end
           prev_parent_ot = @parent_object_type
           @parent_object_type = @current_object_type
           @current_object_type = object_type
-          @path[@path_depth] = "fragment #{node.name}"
-          @path_depth += 1
+          path_depth = @path_depth
+          @path[path_depth] = "fragment #{node.name}"
+          @path_depth = path_depth + 1
           super
           @current_object_type = @parent_object_type
           @parent_object_type = prev_parent_ot
-          @path_depth -= 1
+          @path_depth = path_depth
         end
 
-        INLINE_FRAGMENT_NO_TYPE = "..."
+        INLINE_FRAGMENT_NO_TYPE = "..." #: String
 
+        #: (GraphQL::Language::Nodes::InlineFragment node, GraphQL::Language::Nodes::AbstractNode? parent) -> void
         def on_inline_fragment(node, parent)
-          if node.type
-            object_type = @types.type(node.type.name)
-            @path[@path_depth] = @inline_fragment_paths[node.type.name] ||= -"... on #{node.type.to_query_string}"
-            @path_depth += 1
+          path_depth = @path_depth
+          if (node_type = node.type)
+            object_type = @types.type(node_type.name)
+            @path[path_depth] = @inline_fragment_paths[node_type.name] ||= -"... on #{node_type.to_query_string}"
+            @path_depth = path_depth + 1
           else
             object_type = @current_object_type
-            @path[@path_depth] = INLINE_FRAGMENT_NO_TYPE
-            @path_depth += 1
+            @path[path_depth] = INLINE_FRAGMENT_NO_TYPE
+            @path_depth = path_depth + 1
           end
           prev_parent_ot = @parent_object_type
           @parent_object_type = @current_object_type
@@ -118,14 +145,15 @@ module GraphQL
           super
           @current_object_type = @parent_object_type
           @parent_object_type = prev_parent_ot
-          @path_depth -= 1
+          @path_depth = path_depth
         end
 
+        #: (GraphQL::Language::Nodes::Field node, GraphQL::Language::Nodes::AbstractNode? parent) -> void
         def on_field(node, parent)
           parent_type = @current_object_type
           field_definition = @types.field(parent_type, node.name)
           prev_field_definition = @current_field_definition
-          @current_field_definition = field_definition
+          @current_field_definition = field_definition #: GraphQL::Schema::Field?
           prev_parent_ot = @parent_object_type
           @parent_object_type = @current_object_type
           if field_definition
@@ -133,23 +161,26 @@ module GraphQL
           else
             @current_object_type = nil
           end
-          @path[@path_depth] = node.alias || node.name
-          @path_depth += 1
+          path_depth = @path_depth
+          @path[path_depth] = node.alias || node.name
+          @path_depth = path_depth + 1
           super
           @current_field_definition = prev_field_definition
           @current_object_type = @parent_object_type
           @parent_object_type = prev_parent_ot
-          @path_depth -= 1
+          @path_depth = path_depth
         end
 
+        #: (GraphQL::Language::Nodes::Directive node, GraphQL::Language::Nodes::AbstractNode? parent) -> void
         def on_directive(node, parent)
-          directive_defn = @context.schema_directives[node.name]
+          directive_defn = context.schema_directives[node.name]
           prev_directive_definition = @current_directive_definition
-          @current_directive_definition = directive_defn
+          @current_directive_definition = directive_defn #: singleton(GraphQL::Schema::Directive)?
           super
           @current_directive_definition = prev_directive_definition
         end
 
+        #: (GraphQL::Language::Nodes::Argument node, GraphQL::Language::Nodes::AbstractNode? parent) -> void
         def on_argument(node, parent)
           argument_defn = if (arg = @current_argument_definition)
             arg_type = arg.type.unwrap
@@ -167,39 +198,45 @@ module GraphQL
           end
 
           prev_parent = @parent_argument_definition
-          @parent_argument_definition = @current_argument_definition
-          @current_argument_definition = argument_defn
-          @path[@path_depth] = node.name
-          @path_depth += 1
+          @parent_argument_definition = @current_argument_definition #: GraphQL::Schema::Argument?
+          @current_argument_definition = argument_defn #: GraphQL::Schema::Argument?
+          path_depth = @path_depth
+          @path[path_depth] = node.name
+          @path_depth = path_depth + 1
           super
           @current_argument_definition = @parent_argument_definition
           @parent_argument_definition = prev_parent
-          @path_depth -= 1
+          @path_depth = path_depth
           @child_positions.delete(node)
         end
 
+        #: (GraphQL::Language::Nodes::FragmentSpread node, GraphQL::Language::Nodes::AbstractNode? parent) -> void
         def on_fragment_spread(node, parent)
-          @path[@path_depth] = "... #{node.name}"
-          @path_depth += 1
+          path_depth = @path_depth
+          @path[path_depth] = "... #{node.name}"
+          @path_depth = path_depth + 1
           super
-          @path_depth -= 1
+          @path_depth = path_depth
         end
 
+        #: (GraphQL::Language::Nodes::InputObject node, GraphQL::Language::Nodes::AbstractNode parent) -> void
         def on_input_object(node, parent)
           arg_defn = @current_argument_definition
           if arg_defn && arg_defn.type.list?
-            @path[@path_depth] = child_positions(parent)[node]
-            @path_depth += 1
+            path_depth = @path_depth
+            @path[path_depth] = child_positions(parent)[node] #: as !nil
+            @path_depth = path_depth + 1
             super
-            @path_depth -= 1
+            @path_depth = path_depth
           else
             super
           end
         end
 
+        #: (GraphQL::Language::Nodes::AbstractNode parent) -> Hash[GraphQL::Language::Nodes::AbstractNode, Integer]
         def child_positions(parent)
           @child_positions[parent] ||= begin
-            positions = {}.compare_by_identity
+            positions = {}.compare_by_identity #: Hash[GraphQL::Language::Nodes::AbstractNode, Integer]
             parent.children.each_with_index { |child, index| positions[child] ||= index }
             positions
           end
@@ -211,6 +248,7 @@ module GraphQL
         #
         # :call-seq:
         #   type_definition() -> GraphQL::BaseType
+        #: () -> GraphQL::Schema::Member::type_definition?
         def type_definition
           @current_object_type
         end
@@ -221,6 +259,7 @@ module GraphQL
         #
         # :call-seq:
         #   parent_type_definition() -> GraphQL::BaseType
+        #: () -> GraphQL::Schema::Member::type_definition?
         def parent_type_definition
           @parent_object_type
         end
@@ -231,6 +270,7 @@ module GraphQL
         #
         # :call-seq:
         #   field_definition() -> GraphQL::Field | nil
+        #: () -> GraphQL::Schema::Field?
         def field_definition
           @current_field_definition
         end
@@ -241,6 +281,7 @@ module GraphQL
         #
         # :call-seq:
         #   directive_definition() -> GraphQL::Directive | nil
+        #: () -> singleton(GraphQL::Schema::Directive)?
         def directive_definition
           @current_directive_definition
         end
@@ -251,6 +292,7 @@ module GraphQL
         #
         # :call-seq:
         #   argument_definition() -> GraphQL::Argument | nil
+        #: () -> GraphQL::Schema::Argument?
         def argument_definition
           # Return the parent argument definition (not the current one).
           @parent_argument_definition
@@ -262,6 +304,36 @@ module GraphQL
 
       private
 
+      # These readers expose the visitor's state to `ContextMethods` and to rule modules.
+      # (Sorbet doesn't let a module see a class's instance variables, even with `@requires_ancestor`.)
+
+      #: GraphQL::Schema::Visibility::Profile | GraphQL::Schema::Warden::VisibilityProfile
+      attr_reader :types
+
+      #: singleton(GraphQL::Schema)
+      attr_reader :schema
+
+      # The path entries for every level visited so far. Only the first `path_depth` of them are current; see [path](rdoc-ref:#path).
+      #: () -> Array[String | Integer]
+      def path_parts
+        @path
+      end
+
+      #: Integer
+      attr_accessor :path_depth
+
+      #: Hash[String, String]
+      attr_reader :inline_fragment_paths
+
+      #: Hash[GraphQL::Schema::Field, GraphQL::Schema::Member::type_definition]
+      attr_reader :field_unwrapped_types
+
+      #: () -> Hash[GraphQL::Language::Nodes::AbstractNode, Hash[GraphQL::Language::Nodes::AbstractNode, Integer]]
+      def child_positions_by_parent
+        @child_positions
+      end
+
+      #: (GraphQL::StaticValidation::Error error, ?path: Array[String | Integer]?) -> void
       def add_error(error, path: nil)
         if @context.too_many_errors?
           throw :too_many_validation_errors

data/lib/graphql/static_validation/definition_dependencies.rb

@@ -148,6 +148,8 @@ module GraphQL
         # with that name has a dependency, we record it.
         independent_fragment_nodes = @defdep_fragment_definitions.values.flatten - @defdep_immediate_dependencies.keys
         visited_fragment_names = Set.new
+        # Fragments that share dependencies would otherwise copy them once per path, doubling with each layer.
+        recorded_dependencies = Hash.new { |h, k| h[k] = {}.compare_by_identity }.compare_by_identity
         while fragment_node = independent_fragment_nodes.pop
           if visited_fragment_names.add?(fragment_node.name)
             # this is a new fragment name
@@ -170,8 +172,18 @@ module GraphQL
           else
             fragment_usages.each do |definition_node|
               # Register the dependency AND second-order dependencies
-              dependency_map[definition_node] << fragment_node
-              dependency_map[definition_node].concat(dependency_map[fragment_node])
+              definition_dependencies = dependency_map[definition_node]
+              recorded = recorded_dependencies[definition_node]
+              if !recorded.key?(fragment_node)
+                recorded[fragment_node] = true
+                definition_dependencies << fragment_node
+              end
+              dependency_map[fragment_node].each do |transitive_node|
+                if !recorded.key?(transitive_node)
+                  recorded[transitive_node] = true
+                  definition_dependencies << transitive_node
+                end
+              end
               # Since we've registered it, remove it from our to-do list
               deps = @defdep_immediate_dependencies[definition_node]
               # Can't find a way to _just_ delete from `deps` and return the deleted entries

data/lib/graphql/static_validation/interpreter_visitor.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     class InterpreterVisitor < BaseVisitor

data/lib/graphql/static_validation/rules/argument_names_are_unique.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     #--
@@ -7,16 +7,19 @@ module GraphQL
     module ArgumentNamesAreUnique
       include GraphQL::StaticValidation::Error::ErrorHelper
 
+      #: (GraphQL::Language::Nodes::Field node, GraphQL::Language::Nodes::AbstractNode? parent) -> void
       def on_field(node, parent)
         validate_arguments(node)
         super
       end
 
+      #: (GraphQL::Language::Nodes::Directive node, GraphQL::Language::Nodes::AbstractNode? parent) -> void
       def on_directive(node, parent)
         validate_arguments(node)
         super
       end
 
+      #: (GraphQL::Language::Nodes::Field | GraphQL::Language::Nodes::Directive node) -> void
       def validate_arguments(node)
         argument_defns = node.arguments
         if argument_defns.size > 1

data/lib/graphql/static_validation/rules/directives_are_in_valid_locations.rb

@@ -37,6 +37,8 @@ module GraphQL
 
       def validate_location(ast_directive, ast_parent, directives)
         directive_defn = directives[ast_directive.name]
+        # Undefined directives are reported by DirectivesAreDefined
+        return if directive_defn.nil?
         case ast_parent
         when Nodes::OperationDefinition
           required_location = GraphQL::Schema::Directive.const_get(ast_parent.operation_type.upcase)

data/lib/graphql/static_validation/rules/fields_are_defined_on_type.rb

@@ -1,13 +1,16 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     #--
     # @requires_ancestor: GraphQL::StaticValidation::BaseVisitor
+    # @requires_ancestor: GraphQL::StaticValidation::BaseVisitor::ContextMethods
     module FieldsAreDefinedOnType
+      #: (GraphQL::Language::Nodes::Field node, GraphQL::Language::Nodes::AbstractNode parent) -> void
       def on_field(node, parent)
-        parent_type = @parent_object_type
-        field = context.query.types.field(parent_type, node.name)
+        # Fields are only visited inside a known type (other rules stop the visit otherwise)
+        parent_type = parent_type_definition #: as !nil
+        field = context.types.field(parent_type, node.name)
 
         if field.nil?
           if parent_type.kind.union?
@@ -17,7 +20,7 @@ module GraphQL
               node_name: parent_type.graphql_name
             ))
           else
-            suggestion = if @schema.did_you_mean
+            suggestion = if schema.did_you_mean
               context.did_you_mean_suggestion(node.name, possible_fields(context, parent_type))
             end
             message = "Field '#{node.name}' doesn't exist on type '#{parent_type.graphql_name}'#{suggestion}"
@@ -35,6 +38,7 @@ module GraphQL
 
       private
 
+      #: (GraphQL::StaticValidation::ValidationContext context, GraphQL::Schema::Member::type_definition parent_type) -> Array[String]
       def possible_fields(context, parent_type)
         return EmptyObjects::EMPTY_ARRAY if parent_type.kind.leaf?
         context.types.fields(parent_type).map(&:graphql_name)

data/lib/graphql/static_validation/rules/fragments_are_finite.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     #--
     # @requires_ancestor: GraphQL::StaticValidation::BaseVisitor
     module FragmentsAreFinite
+      #: (GraphQL::Language::Nodes::Document _n, GraphQL::Language::Nodes::AbstractNode? _p) -> void
       def on_document(_n, _p)
         super
         dependency_map = context.dependencies

data/lib/graphql/static_validation/rules/fragments_are_named.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     #--
     # @requires_ancestor: GraphQL::StaticValidation::BaseVisitor
     module FragmentsAreNamed
+      #: (GraphQL::Language::Nodes::FragmentDefinition node, GraphQL::Language::Nodes::AbstractNode? _parent) -> void
       def on_fragment_definition(node, _parent)
         if node.name.nil?
           add_error(GraphQL::StaticValidation::FragmentsAreNamedError.new(

data/lib/graphql/static_validation/rules/fragments_are_named_error.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     class FragmentsAreNamedError < StaticValidation::Error
 
+      #: (String message, ?path: Array[String | Integer]?, ?nodes: GraphQL::Language::Nodes::AbstractNode | Array[GraphQL::Language::Nodes::AbstractNode]) -> void
       def initialize(message, path: nil, nodes: [])
         super(message, path: path, nodes: nodes)
       end
 
       # A hash representation of this Message
+      #: -> Hash[String, untyped]
       def to_h
         extensions = {
           "code" => code,
@@ -19,6 +21,7 @@ module GraphQL
         })
       end
 
+      #: -> String
       def code
         "anonymousFragment"
       end

data/lib/graphql/static_validation/rules/fragments_are_on_composite_types.rb

@@ -1,28 +1,31 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     #--
     # @requires_ancestor: GraphQL::StaticValidation::BaseVisitor
     module FragmentsAreOnCompositeTypes
+      #: (GraphQL::Language::Nodes::FragmentDefinition node, GraphQL::Language::Nodes::AbstractNode parent) -> void
       def on_fragment_definition(node, parent)
         validate_type_is_composite(node) && super
       end
 
+      #: (GraphQL::Language::Nodes::InlineFragment node, GraphQL::Language::Nodes::AbstractNode parent) -> void
       def on_inline_fragment(node, parent)
         validate_type_is_composite(node) && super
       end
 
       private
 
+      #: (GraphQL::Language::Nodes::FragmentDefinition | GraphQL::Language::Nodes::InlineFragment node) -> bool
       def validate_type_is_composite(node)
-        node_type = node.type
+        node_type = node.type #: GraphQL::Language::Nodes::TypeName?
         if node_type.nil?
           # Inline fragment on the same type
           true
         else
           type_name = node_type.to_query_string
-          type_def = @types.type(type_name)
+          type_def = types.type(type_name)
           if type_def.nil? || !type_def.kind.composite?
             add_error(GraphQL::StaticValidation::FragmentsAreOnCompositeTypesError.new(
               "Invalid fragment on type #{type_name} (must be Union, Interface or Object)",

data/lib/graphql/static_validation/rules/fragments_are_used.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     #--
     # @requires_ancestor: GraphQL::StaticValidation::BaseVisitor
     module FragmentsAreUsed
+      #: (GraphQL::Language::Nodes::Document node, GraphQL::Language::Nodes::AbstractNode? parent) -> void
       def on_document(node, parent)
         super
         dependency_map = context.dependencies

data/lib/graphql/static_validation/rules/input_object_names_are_unique.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     #--
     # @requires_ancestor: GraphQL::StaticValidation::BaseVisitor
     module InputObjectNamesAreUnique
+      #: (GraphQL::Language::Nodes::InputObject node, GraphQL::Language::Nodes::AbstractNode? parent) -> void
       def on_input_object(node, parent)
         validate_input_fields(node)
         super
@@ -12,6 +13,7 @@ module GraphQL
 
       private
 
+      #: (GraphQL::Language::Nodes::InputObject node) -> void
       def validate_input_fields(node)
         input_field_defns = node.arguments
         input_fields_by_name = Hash.new { |h, k| h[k] = [] }

data/lib/graphql/static_validation/rules/mutation_root_exists.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     #--
     # @requires_ancestor: GraphQL::StaticValidation::BaseVisitor
     module MutationRootExists
+      #: (GraphQL::Language::Nodes::OperationDefinition node, GraphQL::Language::Nodes::AbstractNode? _parent) -> void
       def on_operation_definition(node, _parent)
-        if node.operation_type == 'mutation' && context.query.types.mutation_root.nil?
+        if node.operation_type == 'mutation' && context.types.mutation_root.nil?
           add_error(GraphQL::StaticValidation::MutationRootExistsError.new(
             'Schema is not configured for mutations',
             nodes: node

data/lib/graphql/static_validation/rules/mutation_root_exists_error.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     class MutationRootExistsError < StaticValidation::Error
 
+      #: (String message, ?path: Array[String | Integer]?, ?nodes: GraphQL::Language::Nodes::AbstractNode | Array[GraphQL::Language::Nodes::AbstractNode]) -> void
       def initialize(message, path: nil, nodes: [])
         super(message, path: path, nodes: nodes)
       end
 
       # A hash representation of this Message
+      #: -> Hash[String, untyped]
       def to_h
         extensions = {
           "code" => code,
@@ -19,6 +21,7 @@ module GraphQL
         })
       end
 
+      #: -> String
       def code
         "missingMutationConfiguration"
       end

data/lib/graphql/static_validation/rules/no_definitions_are_present_error.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     class NoDefinitionsArePresentError < StaticValidation::Error
+      #: (String message, ?path: Array[String | Integer]?, ?nodes: GraphQL::Language::Nodes::AbstractNode | Array[GraphQL::Language::Nodes::AbstractNode]) -> void
       def initialize(message, path: nil, nodes: [])
         super(message, path: path, nodes: nodes)
       end
 
       # A hash representation of this Message
+      #: -> Hash[String, untyped]
       def to_h
         extensions = {
           "code" => code,
@@ -18,6 +20,7 @@ module GraphQL
         })
       end
 
+      #: -> String
       def code
         "queryContainsSchemaDefinitions"
       end

data/lib/graphql/static_validation/rules/not_single_subscription_error.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     class NotSingleSubscriptionError < StaticValidation::Error
+      #: (String message, ?path: Array[String | Integer]?, ?nodes: GraphQL::Language::Nodes::AbstractNode | Array[GraphQL::Language::Nodes::AbstractNode]) -> void
       def initialize(message, path: nil, nodes: [])
         super(message, path: path, nodes: nodes)
       end
 
       # A hash representation of this Message
+      #: -> Hash[String, untyped]
       def to_h
         extensions = {
           "code" => code,
@@ -18,6 +20,7 @@ module GraphQL
         })
       end
 
+      #: -> String
       def code
         "notSingleSubscription"
       end