Merge pull request #50 from block/myron/fix-steep

Upgrade Steep to 1.9 and address new type check failures.

elasticgraph-datastore_core/lib/elastic_graph/datastore_core/index_definition/rollover_index_template.rb

@@ -185,7 +185,7 @@ def rollover_index_suffix_for_record(record, timestamp_field_path:)
             return matching_custom_range.index_name_suffix
           end
 
-          timestamp_value.strftime(ROLLOVER_SUFFIX_FORMATS_BY_FREQUENCY[frequency])
+          timestamp_value.strftime(ROLLOVER_SUFFIX_FORMATS_BY_FREQUENCY.fetch(frequency))
         end
 
         def concrete_rollover_index_for(index_name, setting_overrides, time_set = nil)

elasticgraph-graphql/lib/elastic_graph/graphql/aggregation/query_optimizer.rb

@@ -154,7 +154,7 @@ def unmerge_response(response_from_merged_query, original_query)
           # If there are no aggregations, there's nothing to unmerge--just return it as is.
           return response_from_merged_query unless (aggs = response_from_merged_query["aggregations"])
 
-          prefix = @unique_prefix_by_query[original_query]
+          prefix = @unique_prefix_by_query[original_query] # : ::String
           agg_names = original_query.aggregations.keys.map { |name| "#{prefix}#{name}" }.to_set
 
           filtered_aggs = aggs

elasticgraph-graphql/lib/elastic_graph/graphql/filtering/filter_args_translator.rb

@@ -26,7 +26,7 @@ def initialize(schema_element_names:)
         # vs GraphQL.
         def translate_filter_args(field:, args:)
           return nil unless (filter_hash = args[filter_arg_name])
-          filter_type = field.schema.type_from(field.graphql_field.arguments[filter_arg_name].type)
+          filter_type = field.schema.type_from(field.graphql_field.arguments.fetch(filter_arg_name).type)
           convert(filter_type, filter_hash)
         end
 

elasticgraph-graphql/lib/elastic_graph/graphql/http_endpoint.rb

@@ -197,7 +197,7 @@ def normalized_headers
       end
 
       def content_type
-        @content_type ||= normalized_headers["CONTENT-TYPE"]
+        normalized_headers["CONTENT-TYPE"]
       end
 
       def self.normalize_header_name(header)

elasticgraph-graphql/lib/elastic_graph/graphql/resolvers/query_source.rb

@@ -25,7 +25,7 @@ def initialize(datastore_router, query_tracker)
         def fetch(queries)
           responses_by_query = @datastore_router.msearch(queries, query_tracker: @query_tracker)
           @query_tracker.record_datastore_queries_for_single_request(queries)
-          queries.map { |q| responses_by_query[q] }
+          queries.map { |q| responses_by_query.fetch(q) }
         end
 
         def self.execute_many(queries, for_context:)

elasticgraph-graphql/sig/elastic_graph/graphql/http_endpoint.rbs

@@ -84,8 +84,7 @@ module ElasticGraph
       @normalized_headers: ::Hash[::String, ::String]?
       def normalized_headers: () -> ::Hash[::String, ::String]
 
-      @content_type: ::String?
-      def content_type: () -> ::String
+      def content_type: () -> ::String?
 
       def self.normalize_header_name: (::String) -> ::String
     end

elasticgraph-health_check/lib/elastic_graph/health_check/health_checker.rb

@@ -169,7 +169,7 @@ def validate_and_normalize_config(config)
         #
         # So below, filter to types that have all of their datastore clusters available for querying.
         available_type_names, unavailable_type_names = valid_type_names.partition do |type_name|
-          @indexed_document_types_by_name[type_name].search_index_definitions.all? do |search_index_definition|
+          @indexed_document_types_by_name.fetch(type_name).search_index_definitions.all? do |search_index_definition|
             @datastore_clients_by_name.key?(search_index_definition.cluster_to_query.to_s)
           end
         end
@@ -190,6 +190,7 @@ def validate_and_normalize_config(config)
             .fields_by_name[check.timestamp_field]
 
           if field&.type&.unwrap_fully&.name.to_s == "DateTime"
+            # @type var field: GraphQL::Schema::Field
             # Convert the config so that we have a reference to the index field name.
             normalized_data_recency_checks[type] = check.with(timestamp_field: field.name_in_index.to_s)
           else

elasticgraph-indexer/lib/elastic_graph/indexer/datastore_indexing_router.rb

@@ -77,10 +77,8 @@ def bulk(operations, refresh: false)
         # Before writing these operations, verify their destination index mapping are consistent.
         validate_mapping_completeness_of!(:accessible_cluster_names_to_index_into, *operations.map(&:destination_index_def).uniq)
 
-        # @type var ops_by_client: ::Hash[DatastoreCore::_Client, ::Array[_Operation]]
-        ops_by_client = ::Hash.new { |h, k| h[k] = [] }
-        # @type var unsupported_ops: ::Set[_Operation]
-        unsupported_ops = ::Set.new
+        ops_by_client = ::Hash.new { |h, k| h[k] = [] } # : ::Hash[DatastoreCore::_Client, ::Array[_Operation]]
+        unsupported_ops = ::Set.new # : ::Set[_Operation]
 
         operations.reject { |op| op.to_datastore_bulk.empty? }.each do |op|
           # Note: this intentionally does not use `accessible_cluster_names_to_index_into`.
@@ -90,7 +88,8 @@ def bulk(operations, refresh: false)
 
           cluster_names.each do |cluster_name|
             if (client = @datastore_clients_by_name[cluster_name])
-              ops_by_client[client] << op
+              ops = ops_by_client[client] # : ::Array[::ElasticGraph::Indexer::_Operation]
+              ops << op
             else
               unsupported_ops << op
             end
@@ -293,8 +292,7 @@ def source_event_versions_in_index(operations)
         if failures.empty?
           client_names_and_results.each_with_object(_ = {}) do |(client_name, _success_or_failure, results), accum|
             results.each do |op, version|
-              accum[op] ||= _ = {}
-              accum[op][client_name] = version
+              (accum[op] ||= {})[client_name] = version
             end
           end
         else

elasticgraph-indexer/lib/elastic_graph/indexer/operation/factory.rb

@@ -96,7 +96,7 @@ def select_json_schema_version(event)
         end
 
         def validator(type, selected_json_schema_version)
-          factory = validator_factories_by_version[selected_json_schema_version]
+          factory = validator_factories_by_version[selected_json_schema_version] # : JSONSchema::ValidatorFactory
           factory.validator_for(type)
         end
 

elasticgraph-indexer/lib/elastic_graph/indexer/record_preparer.rb

@@ -31,7 +31,7 @@ def initialize(schema_artifacts)
 
         # Gets the `RecordPreparer` for the given JSON schema version.
         def for_json_schema_version(json_schema_version)
-          @preparers_by_json_schema_version[json_schema_version]
+          @preparers_by_json_schema_version[json_schema_version] # : RecordPreparer
         end
 
         # Gets the `RecordPreparer` for the latest JSON schema version. Intended primarily

elasticgraph-indexer_autoscaler_lambda/lib/elastic_graph/indexer_autoscaler_lambda/concurrency_scaler.rb

@@ -130,7 +130,8 @@ def get_lowest_node_free_storage_in_mb(cluster_name)
           ]
         })
 
-        metric_response.metric_data_results.first.values.first
+        results = metric_response.metric_data_results.first # : ::Aws::CloudWatch::Types::MetricDataResult
+        results.values.first.to_f
       end
 
       def get_queue_attributes(queue_urls)

elasticgraph-json_schema/lib/elastic_graph/json_schema/validator_factory.rb

@@ -55,7 +55,7 @@ def initialize(schema:, sanitize_pii:)
       # @param type_name [String] name of an ElasticGraph type
       # @return [Validator]
       def validator_for(type_name)
-        @validators_by_type_name[type_name]
+        @validators_by_type_name[type_name] # : Validator
       end
 
       # Returns a new factory configured to disallow unknown properties. By default, JSON schema

elasticgraph-query_registry/lib/elastic_graph/query_registry/query_validator.rb

@@ -60,8 +60,8 @@ def variables_errors_for(operation_name, old_dumped_variables, new_dumped_variab
           return [{"message" => "No dumped variables for this operation exist. Correct by running: `#{rake_task}`"}]
         end
 
-        old_op_vars = old_dumped_variables[operation_name]
-        new_op_vars = new_dumped_variables[operation_name]
+        old_op_vars = old_dumped_variables.fetch(operation_name)
+        new_op_vars = new_dumped_variables.fetch(operation_name)
 
         if old_op_vars == new_op_vars
           # The previously dumped variables are up-to-date. No errors in this case.

elasticgraph-query_registry/lib/elastic_graph/query_registry/variable_backward_incompatibility_detector.rb

@@ -32,12 +32,12 @@ def detect_incompatibilities(old, new, path, entry_type)
         end
 
         incompatible_commonalities = commonalities.flat_map do |name|
-          incompatibilities_for("#{path}#{name}", normalize_type_info(old[name]), normalize_type_info(new[name]))
+          incompatibilities_for("#{path}#{name}", normalize_type_info(old.fetch(name)), normalize_type_info(new.fetch(name)))
         end
 
         incompatible_additions = additions.filter_map do |name|
           # Additions are only incompatible if it's required (non-nullable).
-          _ = if normalize_type_info(new[name]).fetch("type").end_with?("!")
+          _ = if normalize_type_info(new.fetch(name)).fetch("type").end_with?("!")
             Incompatibility.new("#{path}#{name}", "new required #{entry_type}")
           end
         end

elasticgraph-schema_artifacts/lib/elastic_graph/schema_artifacts/from_disk.rb

@@ -47,7 +47,7 @@ def json_schemas_for(version)
             "Available versions: #{available_json_schema_versions.sort.join(", ")}."
         end
 
-        json_schemas_by_version[version]
+        json_schemas_by_version[version] # : ::Hash[::String, untyped]
       end
 
       def available_json_schema_versions

elasticgraph-schema_artifacts/lib/elastic_graph/schema_artifacts/runtime_metadata/extension_loader.rb

@@ -117,7 +117,7 @@ def signature_code_for(object, method_name)
           # @type var file_name: ::String?
           # @type var line_number: ::Integer?
           file_name, line_number = object.instance_method(method_name).source_location
-          ::File.read(file_name.to_s).split("\n")[line_number.to_i - 1].strip
+          ::File.read(file_name.to_s).split("\n").fetch(line_number.to_i - 1).strip
         end
       end
     end

elasticgraph-schema_definition/lib/elastic_graph/schema_definition/mixins/has_derived_graphql_type_customizations.rb

@@ -50,7 +50,8 @@ def customize_derived_types(*type_names, &customization_block)
             derived_type_customizations_for_all_types << customization_block
           else
             type_names.each do |t|
-              derived_type_customizations_by_name[t.to_s] << customization_block
+              derived_type_customizations = derived_type_customizations_by_name[t.to_s] # : ::Array[^(::ElasticGraph::SchemaDefinition::_Type) -> void]
+              derived_type_customizations << customization_block
             end
           end
         end
@@ -75,21 +76,23 @@ def customize_derived_types(*type_names, &customization_block)
         #     end
         #   end
         def customize_derived_type_fields(type_name, *field_names, &customization_block)
-          customizations_by_field = derived_field_customizations_by_type_and_field_name[type_name]
+          customizations_by_field = derived_field_customizations_by_type_and_field_name[type_name] # : ::Hash[::String, ::Array[^(::ElasticGraph::SchemaDefinition::SchemaElements::Field) -> void]]
 
           field_names.each do |field_name|
-            customizations_by_field[field_name] << customization_block
+            customizations = customizations_by_field[field_name] # : ::Array[^(::ElasticGraph::SchemaDefinition::SchemaElements::Field) -> void]
+            customizations << customization_block
           end
         end
 
         # @private
         def derived_type_customizations_for_type(type)
-          derived_type_customizations_by_name[type.name] + derived_type_customizations_for_all_types
+          derived_type_customizations = derived_type_customizations_by_name[type.name] # : ::Array[^(::ElasticGraph::SchemaDefinition::_Type) -> void]
+          derived_type_customizations + derived_type_customizations_for_all_types
         end
 
         # @private
         def derived_field_customizations_by_name_for_type(type)
-          derived_field_customizations_by_type_and_field_name[type.name]
+          derived_field_customizations_by_type_and_field_name[type.name] # : ::Hash[::String, ::Array[^(SchemaElements::Field) -> void]]
         end
 
         # @private

elasticgraph-schema_definition/lib/elastic_graph/schema_definition/mixins/has_subtypes.rb

@@ -75,8 +75,9 @@ def merge_fields_by_name_from_subtypes
             fields_by_name.merge(yield subtype) do |field_name, def1, def2|
               if (def1.name_in_index == def2.name_in_index && def1.resolve_mapping != def2.resolve_mapping) || (def1.type.unwrap_non_null != def2.type.unwrap_non_null)
                 def_strings = resolved_subtypes.each_with_object([]) do |st, defs|
-                  field = st.graphql_fields_by_name[field_name]
-                  defs << "on #{st.name}:\n#{field.to_sdl.strip} mapping: #{field.resolve_mapping.inspect}" if st.graphql_fields_by_name.key?(field_name)
+                  if (field = st.graphql_fields_by_name[field_name])
+                    defs << "on #{st.name}:\n#{field.to_sdl.strip} mapping: #{field.resolve_mapping.inspect}"
+                  end
                 end
 
                 raise Errors::SchemaError,

elasticgraph-schema_definition/lib/elastic_graph/schema_definition/mixins/implements_interfaces.rb

@@ -43,7 +43,8 @@ module ImplementsInterfaces
         def implements(*interface_names)
           interface_refs = interface_names.map do |interface_name|
             schema_def_state.type_ref(interface_name).to_final_form.tap do |interface_ref|
-              schema_def_state.implementations_by_interface_ref[interface_ref] << self
+              implementations = schema_def_state.implementations_by_interface_ref[interface_ref] # : ::Set[SchemaElements::TypeWithSubfields]
+              implementations << self
             end
           end
 

elasticgraph-schema_definition/lib/elastic_graph/schema_definition/results.rb

@@ -329,7 +329,7 @@ def check_for_circular_dependencies!
 
       def recursively_add_referenced_types_to(source_type_ref, references_cache)
         return unless (source_type = source_type_ref.as_object_type)
-        references_set = references_cache[source_type_ref.name]
+        references_set = references_cache[source_type_ref.name] # : ::Set[::String]
 
         # Recursive references are allowed only when its a relation, so skip that case.
         source_type.graphql_fields_by_name.values.reject { |f| f.relationship }.each do |field|
@@ -339,7 +339,8 @@ def recursively_add_referenced_types_to(source_type_ref, references_cache)
             recursively_add_referenced_types_to(field_type, references_cache)
           end
 
-          references_set.merge(references_cache[field_type.name])
+          field_type_references_set = references_cache[field_type.name] # : ::Set[::String]
+          references_set.merge(field_type_references_set)
         end
       end
 

elasticgraph-schema_definition/lib/elastic_graph/schema_definition/schema_elements/enum_value_namer.rb

@@ -29,7 +29,8 @@ def initialize(overrides_by_type_name = {})
 
         # Returns the name that should be used for the given `type_name` and `value_name`.
         def name_for(type_name, value_name)
-          @used_value_names_by_type_name[type_name] << value_name
+          used_value_names = @used_value_names_by_type_name[type_name] # : ::Array[::String]
+          used_value_names << value_name
           overrides_by_type_name.dig(type_name, value_name) || value_name
         end
 

elasticgraph-schema_definition/lib/elastic_graph/schema_definition/state.rb

@@ -139,15 +139,17 @@ def register_deleted_type(type_name, defined_at:, defined_via:)
       end
 
       def register_renamed_field(type_name, from:, to:, defined_at:, defined_via:)
-        renamed_fields_by_type_name_and_old_field_name[type_name][from] = factory.new_deprecated_element(
+        renamed_fields_by_old_field_name = renamed_fields_by_type_name_and_old_field_name[type_name] # : ::Hash[::String, SchemaElements::DeprecatedElement]
+        renamed_fields_by_old_field_name[from] = factory.new_deprecated_element(
           to,
           defined_at: defined_at,
           defined_via: defined_via
         )
       end
 
       def register_deleted_field(type_name, field_name, defined_at:, defined_via:)
-        deleted_fields_by_type_name_and_old_field_name[type_name][field_name] = factory.new_deprecated_element(
+        deleted_fields_by_old_field_name = deleted_fields_by_type_name_and_old_field_name[type_name] # : ::Hash[::String, SchemaElements::DeprecatedElement]
+        deleted_fields_by_old_field_name[field_name] = factory.new_deprecated_element(
           field_name,
           defined_at: defined_at,
           defined_via: defined_via

gemspec_helper.rb

@@ -60,7 +60,10 @@ def self.define_elasticgraph_gem(gemspec_file:, category:)
 
       # Steep is our type checker. Only needed if there's a `sig` directory.
       if ::Dir.exist?(::File.join(gem_dir, "sig"))
-        spec.add_development_dependency "steep", "~> 1.8"
+        # New steep minor versions often introduce stricter type checks that we may initially fail,
+        # so we don't want to automatically upgrade when a new steep minor version is released.
+        # Therefore, we list 3 digits (in contrast to most gems).
+        spec.add_development_dependency "steep", "~> 1.9.0"
       end
 
       # If the gem has a `spec` directory then it needs our standard set of testing gems.