graphql 2.6.14 → 2.6.15

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

@@ -6,6 +6,7 @@ module GraphQL
     # @requires_ancestor: GraphQL::StaticValidation::BaseVisitor
     # @requires_ancestor: GraphQL::StaticValidation::RequiredInputObjectAttributesArePresent
     module OneOfInputObjectsAreValid
+      #: (GraphQL::Language::Nodes::InputObject node, GraphQL::Language::Nodes::AbstractNode parent) -> void
       def on_input_object(node, parent)
         return super unless parent.is_a?(GraphQL::Language::Nodes::Argument)
 
@@ -18,6 +19,7 @@ module GraphQL
 
       private
 
+      #: (GraphQL::Language::Nodes::InputObject ast_node, GraphQL::StaticValidation::ValidationContext context, singleton(GraphQL::Schema::InputObject) parent_type) -> void
       def validate_one_of_input_object(ast_node, context, parent_type)
         present_fields = ast_node.arguments.map(&:name)
         input_object_type = parent_type.to_type_signature
@@ -35,7 +37,9 @@ module GraphQL
         end
 
         field = present_fields.first
-        value = ast_node.arguments.first.value
+        # `present_fields.count == 1` was checked above:
+        argument = ast_node.arguments.first #: as !nil
+        value = argument.value
 
         if value.is_a?(GraphQL::Language::Nodes::NullValue)
           add_error(
@@ -51,7 +55,10 @@ module GraphQL
 
         if value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
           variable_name = value.name
-          variable_type = @declared_variables[variable_name].type
+          variable_definition = @declared_variables && @declared_variables[variable_name]
+          # Undeclared variables are reported by VariablesAreUsedAndDefined
+          return if variable_definition.nil?
+          variable_type = variable_definition.type
 
           unless variable_type.is_a?(GraphQL::Language::Nodes::NonNullType)
             add_error(

data/lib/graphql/static_validation/rules/query_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 QueryRootExists
+      #: (GraphQL::Language::Nodes::OperationDefinition node, GraphQL::Language::Nodes::AbstractNode? _parent) -> void
       def on_operation_definition(node, _parent)
-        if (node.operation_type == 'query' || node.operation_type.nil?) && context.query.types.query_root.nil?
+        if (node.operation_type == 'query' || node.operation_type.nil?) && context.types.query_root.nil?
           add_error(GraphQL::StaticValidation::QueryRootExistsError.new(
             'Schema is not configured for queries',
             nodes: node

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

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     class QueryRootExistsError < 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
         "missingQueryConfiguration"
       end

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

@@ -1,20 +1,25 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     class RequiredInputObjectAttributesArePresentError < StaticValidation::Error
+      #: String
       attr_reader :argument_type
+      #: String
       attr_reader :argument_name
+      #: String
       attr_reader :input_object_type
 
+      #: (String message, path: Array[String | Integer]?, nodes: GraphQL::Language::Nodes::AbstractNode | Array[GraphQL::Language::Nodes::AbstractNode], argument_type: String, argument_name: String, input_object_type: String) -> void
       def initialize(message, path:, nodes:, argument_type:, argument_name:, input_object_type:)
         super(message, path: path, nodes: nodes)
-        @argument_type = argument_type
-        @argument_name = argument_name
-        @input_object_type = input_object_type
+        @argument_type = argument_type #: String
+        @argument_name = argument_name #: String
+        @input_object_type = input_object_type #: String
       end
 
       # A hash representation of this Message
+      #: () -> Hash[String, untyped]
       def to_h
         extensions = {
           "code" => code,
@@ -28,6 +33,7 @@ module GraphQL
         })
       end
 
+      #: () -> String
       def code
         "missingRequiredInputObjectAttribute"
       end

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

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     #--
     # @requires_ancestor: GraphQL::StaticValidation::BaseVisitor
     module SubscriptionRootExistsAndSingleSubscriptionSelection
+      #: (GraphQL::Language::Nodes::OperationDefinition node, GraphQL::Language::Nodes::AbstractNode parent) -> void
       def on_operation_definition(node, parent)
         if node.operation_type == "subscription"
           if context.types.subscription_root.nil?
@@ -34,11 +35,12 @@ module GraphQL
 
       private
 
+      #: (GraphQL::Language::Nodes::OperationDefinition node) -> Array[GraphQL::Language::Nodes::Field]
       def subscription_root_fields(node)
         root_type = context.types.subscription_root
-        fields = []
-        selections = node.selections.dup
-        visited_fragments = {}
+        fields = [] #: Array[GraphQL::Language::Nodes::Field]
+        selections = node.selections.dup #: Array[GraphQL::Language::Nodes::Field | GraphQL::Language::Nodes::FragmentSpread | GraphQL::Language::Nodes::InlineFragment | GraphQL::Language::Nodes::FragmentDefinition]
+        visited_fragments = {} #: Hash[String, bool]
 
         while (selection = selections.pop)
           case selection
@@ -50,8 +52,8 @@ module GraphQL
             fragment = context.fragments[selection.name]
             selections << fragment if fragment
           when GraphQL::Language::Nodes::InlineFragment, GraphQL::Language::Nodes::FragmentDefinition
-            fragment_type = (selection_type = selection.type) ? @types.type(selection_type.name) : root_type
-            if fragment_type && fragment_type.kind.composite? && @types.possible_types(fragment_type).include?(root_type)
+            fragment_type = (selection_type = selection.type) ? types.type(selection_type.name) : root_type
+            if fragment_type && fragment_type.kind.composite? && types.possible_types(fragment_type).include?(root_type)
               selections.concat(selection.selections)
             end
           end

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

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     class SubscriptionRootExistsError < 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
         "missingSubscriptionConfiguration"
       end

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     #--
@@ -20,7 +20,7 @@ module GraphQL
         :on_enum_value_definition,
         :on_input_object_type_definition,
         :on_field,
-      ]
+      ] #: Array[Symbol]
 
       VALIDATE_DIRECTIVE_LOCATION_ON_NODE = <<~RUBY
         def %{method_name}(node, parent)
@@ -37,12 +37,13 @@ module GraphQL
 
       private
 
+      #: (GraphQL::Language::Nodes::FragmentDefinition | GraphQL::Language::Nodes::FragmentSpread | GraphQL::Language::Nodes::InlineFragment | GraphQL::Language::Nodes::OperationDefinition | GraphQL::Language::Nodes::ScalarTypeDefinition | GraphQL::Language::Nodes::ObjectTypeDefinition | GraphQL::Language::Nodes::InputValueDefinition | GraphQL::Language::Nodes::FieldDefinition | GraphQL::Language::Nodes::InterfaceTypeDefinition | GraphQL::Language::Nodes::UnionTypeDefinition | GraphQL::Language::Nodes::EnumTypeDefinition | GraphQL::Language::Nodes::EnumValueDefinition | GraphQL::Language::Nodes::InputObjectTypeDefinition | GraphQL::Language::Nodes::Field node) -> void
       def validate_directive_location(node)
-        used_directives = {}
+        used_directives = {} #: Hash[String, GraphQL::Language::Nodes::Directive]
         node.directives.each do |ast_directive|
           directive_name = ast_directive.name
           if (first_node = used_directives[directive_name])
-            @directives_are_unique_errors_by_first_node ||= {}
+            @directives_are_unique_errors_by_first_node ||= {} #: Hash[GraphQL::Language::Nodes::Directive, GraphQL::StaticValidation::UniqueDirectivesPerLocationError]?
             err = @directives_are_unique_errors_by_first_node[first_node] ||= begin
               error = GraphQL::StaticValidation::UniqueDirectivesPerLocationError.new(
                 "The directive \"#{directive_name}\" can only be used once at this location.",

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

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     #--
     # @requires_ancestor: GraphQL::StaticValidation::BaseVisitor
     module VariableDefaultValuesAreCorrectlyTyped
+      #: (GraphQL::Language::Nodes::VariableDefinition node, GraphQL::Language::Nodes::AbstractNode? parent) -> void
       def on_variable_definition(node, parent)
         if !node.default_value.nil?
           value = node.default_value

data/lib/graphql/static_validation/rules/variable_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 VariableNamesAreUnique
+      #: (GraphQL::Language::Nodes::OperationDefinition node, GraphQL::Language::Nodes::AbstractNode? parent) -> void
       def on_operation_definition(node, parent)
         var_defns = node.variables
         if !var_defns.empty?

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

@@ -12,7 +12,7 @@ module GraphQL
       def initialize(*)
         super
         # holds { name => ast_node } pairs
-        @declared_variables = {}
+        @declared_variables = {} #: Hash[String, GraphQL::Language::Nodes::VariableDefinition]
         @operation_declared_variables = {}.compare_by_identity #: Hash[GraphQL::Language::Nodes::OperationDefinition, Hash[String, GraphQL::Language::Nodes::VariableDefinition]]
         @variable_usages_fragment_definition = nil
         @fragment_variable_usages = nil #: Hash[GraphQL::Language::Nodes::FragmentDefinition, Array[FragmentVariableUsage]]?

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

@@ -7,7 +7,7 @@ module GraphQL
     module VariablesAreInputTypes
       def on_variable_definition(node, parent)
         type_name = get_type_name(node.type)
-        type = context.query.types.type(type_name)
+        type = context.types.type(type_name)
 
         if type.nil?
           suggestion = if @schema.did_you_mean

data/lib/graphql/static_validation/validation_context.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     # The validation context gets passed to each validator.
@@ -12,22 +12,40 @@ module GraphQL
     class ValidationContext
       extend Forwardable
 
-      attr_reader :query, :errors, :visitor,
-        :on_dependency_resolve_handlers,
-        :max_errors, :types, :schema
+      #: GraphQL::Query
+      attr_reader :query
+
+      #: Array[GraphQL::StaticValidation::Error]
+      attr_reader :errors
+
+      #: GraphQL::StaticValidation::BaseVisitor
+      attr_reader :visitor
+
+      #: Array[^(GraphQL::Language::Nodes::OperationDefinition | GraphQL::Language::Nodes::FragmentDefinition, Array[GraphQL::Language::Nodes::FragmentSpread], GraphQL::Language::Nodes::FragmentDefinition) -> void]
+      attr_reader :on_dependency_resolve_handlers
+
+      #: Integer | Float
+      attr_reader :max_errors
+
+      #: GraphQL::Schema::Visibility::Profile | GraphQL::Schema::Warden::VisibilityProfile
+      attr_reader :types
+
+      #: singleton(GraphQL::Schema)
+      attr_reader :schema
 
 
       def_delegators :@query, :document, :fragments, :operations
 
+      #: (GraphQL::Query query, singleton(GraphQL::StaticValidation::BaseVisitor) visitor_class, Integer? max_errors) -> void
       def initialize(query, visitor_class, max_errors)
-        @query = query
-        @types = query.types # TODO update migrated callers to use this accessor
-        @schema = query.schema
-        @literal_validator = LiteralValidator.new(context: query.context)
-        @errors = []
-        @max_errors = max_errors || Float::INFINITY
-        @on_dependency_resolve_handlers = []
-        @visitor = visitor_class.new(document, self)
+        @query = query #: GraphQL::Query
+        @types = query.types #: GraphQL::Schema::Visibility::Profile | GraphQL::Schema::Warden::VisibilityProfile
+        @schema = query.schema #: singleton(GraphQL::Schema)
+        @input_values = query.input_values #: GraphQL::Execution::InputValues
+        @errors = [] #: Array[GraphQL::StaticValidation::Error]
+        @max_errors = max_errors || Float::INFINITY #: Integer | Float
+        @on_dependency_resolve_handlers = [] #: Array[^(GraphQL::Language::Nodes::OperationDefinition | GraphQL::Language::Nodes::FragmentDefinition, Array[GraphQL::Language::Nodes::FragmentSpread], GraphQL::Language::Nodes::FragmentDefinition) -> void]
+        @visitor = visitor_class.new(document, self) #: GraphQL::StaticValidation::BaseVisitor
       end
 
       # TODO stop using def_delegators because of Array allocations
@@ -35,22 +53,39 @@ module GraphQL
         :path, :type_definition, :field_definition, :argument_definition,
         :parent_type_definition, :directive_definition, :dependencies
 
+      #: () { (GraphQL::Language::Nodes::OperationDefinition | GraphQL::Language::Nodes::FragmentDefinition, Array[GraphQL::Language::Nodes::FragmentSpread], GraphQL::Language::Nodes::FragmentDefinition) -> void } -> void
       def on_dependency_resolve(&handler)
         @on_dependency_resolve_handlers << handler
       end
 
+      INVALID_RESULT = GraphQL::Query::InputValidationResult.new(valid: false, problems: EmptyObjects::EMPTY_ARRAY).freeze #: GraphQL::Query::InputValidationResult
+      private_constant :INVALID_RESULT
+
+      #: (untyped ast_value, GraphQL::Schema::Member::type_definition | GraphQL::Schema::NonNull | GraphQL::Schema::List type) -> GraphQL::Query::InputValidationResult
       def validate_literal(ast_value, type)
-        @literal_validator.validate(ast_value, type)
+        @input_values.value_from_ast(ast_value, type, validate: true)
+        GraphQL::Query::InputValidationResult::VALID
+      rescue Execution::InputValues::InvalidLiteralError => err
+        if err.explanation
+          Query::InputValidationResult.from_problem(err.explanation)
+        else
+          INVALID_RESULT
+        end
+      rescue CoercionError => coercion_err
+        Query::InputValidationResult.from_problem(coercion_err.message, message: coercion_err.message, extensions: coercion_err.extensions)
       end
 
+      #: () -> bool
       def too_many_errors?
         @errors.length >= @max_errors
       end
 
+      #: () -> Hash[String, singleton(GraphQL::Schema::Directive)]
       def schema_directives
-        @schema_directives ||= schema.directives
+        @schema_directives ||= schema.directives #: Hash[String, singleton(GraphQL::Schema::Directive)]?
       end
 
+      #: (String name, Array[String] options) -> String?
       def did_you_mean_suggestion(name, options)
         if did_you_mean = schema.did_you_mean
           suggestions = did_you_mean.const_get(:SpellChecker).new(dictionary: options).correct(name)

data/lib/graphql/static_validation/validation_timeout_error.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module StaticValidation
     class ValidationTimeoutError < 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
         "validationTimeout"
       end

data/lib/graphql/static_validation.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 require "graphql/static_validation/error"
 require "graphql/static_validation/definition_dependencies"
 require "graphql/static_validation/validator"
 require "graphql/static_validation/validation_context"
 require "graphql/static_validation/validation_timeout_error"
-require "graphql/static_validation/literal_validator"
 require "graphql/static_validation/base_visitor"
 
 rules_glob = File.expand_path("../static_validation/rules/*.rb", __FILE__)

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -106,13 +106,7 @@ module GraphQL
         # A per-process map of subscriptions to deliver.
         # This is provided by Rails, so let's use it
         @subscriptions = Concurrent::Map.new
-        @events = Concurrent::Map.new do |h, k|
-          h.compute_if_absent(k) do
-            Concurrent::Map.new do |h2, k2|
-              h2.compute_if_absent(k2) { Concurrent::Array.new }
-            end
-          end
-        end
+        @events = Concurrent::Map.new
         @action_cable = action_cable
         @action_cable_coder = action_cable_coder
         @serializer = serializer
@@ -164,7 +158,11 @@ module GraphQL
           # Setup a new listener to run all events with this topic in this process
           setup_stream(channel, event)
           # Add this event to the list of events to be updated
-          @events[event.topic][event.fingerprint] << event
+          @events.compute(event.topic) do |events_by_fingerprint|
+            events_by_fingerprint ||= Concurrent::Map.new
+            events_by_fingerprint.compute_if_absent(event.fingerprint) { Concurrent::Array.new } << event
+            events_by_fingerprint
+          end
         end
       end
 
@@ -184,6 +182,8 @@ module GraphQL
         event_stream = stream_event_name(initial_event)
         channel.stream_from(event_stream, coder: @action_cable_coder) do |message|
           events_by_fingerprint = @events[topic]
+          next if events_by_fingerprint.nil?
+
           object = nil #: untyped
           events_by_fingerprint.each do |_fingerprint, events|
             if !events.empty? && events.first == initial_event
@@ -252,11 +252,12 @@ module GraphQL
         if query
           events = query.context.namespace(:subscriptions)[:events]
           events.each do |event|
-            ev_by_fingerprint = @events[event.topic]
-            ev_for_fingerprint = ev_by_fingerprint[event.fingerprint]
-            ev_for_fingerprint.delete(event)
-            if ev_for_fingerprint.empty?
-              ev_by_fingerprint.delete(event.fingerprint)
+            @events.compute_if_present(event.topic) do |events_by_fingerprint|
+              events_by_fingerprint.compute_if_present(event.fingerprint) do |events_for_fingerprint|
+                events_for_fingerprint.delete(event)
+                events_for_fingerprint.empty? ? nil : events_for_fingerprint
+              end
+              events_by_fingerprint.empty? ? nil : events_by_fingerprint
             end
           end
         end

data/lib/graphql/testing.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 require "graphql/testing/helpers"
 require "graphql/testing/mock_action_cable"

data/lib/graphql/tracing/legacy_trace.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 
 require "graphql/tracing/trace"
 require "graphql/tracing/call_legacy_tracers"

data/lib/graphql/tracing/null_trace.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 
 require "graphql/tracing/trace"
 

data/lib/graphql/types/big_int.rb

@@ -1,21 +1,24 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 
 module GraphQL
   module Types
     class BigInt < GraphQL::Schema::Scalar
       description "Represents non-fractional signed whole numeric values. Since the value may exceed the size of a 32-bit integer, it's encoded as a string."
 
+      #: (untyped value, GraphQL::Query::Context _ctx) -> (::Numeric | false | nil)
       def self.coerce_input(value, _ctx)
         value && parse_int(value)
       rescue ArgumentError
         nil
       end
 
+      #: (untyped value, GraphQL::Query::Context _ctx) -> ::String
       def self.coerce_result(value, _ctx)
         value.to_i.to_s
       end
 
+      #: (untyped value) -> ::Numeric
       def self.parse_int(value)
         value.is_a?(Numeric) ? value : Integer(value, 10)
       end

data/lib/graphql/types/boolean.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module Types
     class Boolean < GraphQL::Schema::Scalar
       description "Represents `true` or `false` values."
 
+      #: (untyped value, GraphQL::Query::Context _ctx) -> bool?
       def self.coerce_input(value, _ctx)
         (value == true || value == false) ? value : nil
       end
 
+      #: (untyped value, GraphQL::Query::Context _ctx) -> bool
       def self.coerce_result(value, _ctx)
         !!value
       end

data/lib/graphql/types/id.rb

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module Types
     class ID < GraphQL::Schema::Scalar
       graphql_name "ID"
       description "Represents a unique identifier that is Base64 obfuscated. It is often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `\"VXNlci0xMA==\"`) or integer (such as `4`) input value will be accepted as an ID."
       default_scalar true
+      #: (untyped value, GraphQL::Query::Context _ctx) -> ::String
       def self.coerce_result(value, _ctx)
         value.is_a?(::String) ? value : value.to_s
       end
 
+      #: (untyped value, GraphQL::Query::Context _ctx) -> ::String?
       def self.coerce_input(value, _ctx)
         case value
         when ::String

data/lib/graphql/types/iso_8601_date.rb

@@ -27,6 +27,7 @@ module GraphQL
       #
       # :call-seq:
       #   coerce_result(Date | Time | DateTime | String value, _ctx) -> String
+      #: (untyped value, GraphQL::Query::Context _ctx) -> ::String
       def self.coerce_result(value, _ctx)
         Date.parse(value.to_s).iso8601
       end

data/lib/graphql/types/iso_8601_date_time.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 
 require 'time'
 
@@ -30,6 +30,7 @@ module GraphQL
       #
       # :call-seq:
       #   time_precision() -> Integer
+      #: -> Integer
       def self.time_precision
         @time_precision || DEFAULT_TIME_PRECISION
       end
@@ -40,8 +41,9 @@ module GraphQL
       #
       # :call-seq:
       #   time_precision=(Integer value)
+      #: (Integer value) -> void
       def self.time_precision=(value)
-        @time_precision = value
+        @time_precision = value #: Integer?
       end
 
       # **Parameters**
@@ -54,6 +56,7 @@ module GraphQL
       #
       # :call-seq:
       #   coerce_result(Time | Date | DateTime | String value, _ctx) -> String
+      #: (untyped value, GraphQL::Query::Context _ctx) -> ::String
       def self.coerce_result(value, _ctx)
         case value
         when Date
@@ -78,6 +81,7 @@ module GraphQL
       #
       # :call-seq:
       #   coerce_input(String str_value, _ctx) -> Time
+      #: (untyped str_value, GraphQL::Query::Context _ctx) -> ::Time?
       def self.coerce_input(str_value, _ctx)
         Time.iso8601(str_value)
       rescue ArgumentError, TypeError

data/lib/graphql/types/iso_8601_duration.rb

@@ -23,6 +23,7 @@ module GraphQL
       #
       # :call-seq:
       #   seconds_precision() -> Integer | nil
+      #: -> Integer?
       def self.seconds_precision
         # ActiveSupport::Duration precision defaults to whatever input was given
         @seconds_precision
@@ -34,6 +35,7 @@ module GraphQL
       #
       # :call-seq:
       #   seconds_precision=(Integer | nil value)
+      #: (Integer? value) -> Integer?
       def self.seconds_precision=(value)
         @seconds_precision = value
       end
@@ -52,6 +54,7 @@ module GraphQL
       #
       # :call-seq:
       #   coerce_result(ActiveSupport::Duration | String value, _ctx) -> String | GraphQL::Error
+      #: (untyped value, GraphQL::Query::Context _ctx) -> ::String
       def self.coerce_result(value, _ctx)
         unless defined?(ActiveSupport::Duration)
           raise GraphQL::Error, "ActiveSupport >= 5.0 must be loaded to use the built-in ISO8601Duration type."

data/lib/graphql/types/relay/base_connection.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 
 module GraphQL
   module Types

data/lib/graphql/types/relay/base_edge.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module Types
     module Relay

data/lib/graphql/types/relay/node.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 
 module GraphQL
   module Types

data/lib/graphql/types/relay/page_info.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module Types
     module Relay