Add GraphQL::Schema::Type helpers needed for query-time __typename filtering

This is a companion/pre-requisite PR to add methods supporting __typename filter injection when querying mixed-type indexes via index inheritance.
  * `source_type`: resolves the underlying document type for derived types (e.g. indexed aggregations) so the filter can look up search indexes on the source rather than the aggregation type
  * `subtypes`: declared in RBS so Steep-checked callers can use it
  * `non_subtypes_in_shared_index`: identifies concrete types sharing an index with this type that are not subtypes — the presence of any such types is what triggers the need for a __typename filter

Author: marcdaniels-toast

elasticgraph-graphql/lib/elastic_graph/graphql/schema/type.rb

@@ -76,7 +76,7 @@ def search_index_definitions
               # We can go from `Inventor` to its subtypes to find the search indexes. However, `InventorAggregation`
               # is NOT a union of `PersonAggregation` and `CompanyAggregation`, so we can't do the same thing on the
               # indexed aggregation types. Delegating to the source type solves this case.
-              @schema.type_named(@object_runtime_metadata.source_type).search_index_definitions
+              source_type.search_index_definitions
             else
               @index_definitions.union(subtypes.flat_map(&:search_index_definitions))
             end
@@ -117,7 +117,7 @@ def unwrap_fully
           end
         end
 
-        # Returns the subtypes of this type, if it has any. This is like `#possible_types` provided by the
+        # Returns all concrete subtypes, at any depth. This is like `#possible_types` provided by the
         # GraphQL gem, but that includes a type itself when you ask for the possible types of a non-abstract type.
         def subtypes
           @subtypes ||= @schema
@@ -126,6 +126,34 @@ def subtypes
             .map { |t| @schema.type_from(t) } - [self]
         end
 
+        # For derived types (e.g. indexed aggregations), returns the underlying source document type.
+        # For non-derived types, returns `self`.
+        def source_type
+          @source_type ||=
+            if (st = @object_runtime_metadata.source_type)
+              @schema.type_named(st)
+            else
+              self
+            end
+        end
+
+        # Returns the set of concrete indexed document types that share any of this type's search
+        # indexes but are not subtypes of this type. Used to determine whether a `__typename`
+        # filter is needed when querying an abstract type.
+        #
+        # Abstract types are excluded because documents in the datastore are always associated
+        # with a concrete `__typename`. When filtering by `__typename`, only concrete types are
+        # relevant.
+        def non_subtypes_in_shared_index
+          @non_subtypes_in_shared_index ||= begin
+            all_subtypes = subtypes.to_set # all concrete subtypes at any depth
+            search_index_definitions
+              .flat_map { |index_def| @schema.document_types_stored_in(index_def.name).to_a }
+              .reject { |t| t == self || all_subtypes.include?(t) || t.abstract? }
+              .to_set
+          end
+        end
+
         def field_named(field_name)
           @fields_by_name.fetch(field_name)
         rescue KeyError => e

elasticgraph-graphql/sig/elastic_graph/graphql/schema/type.rbs

@@ -9,6 +9,9 @@ module ElasticGraph
         attr_reader graphql_type: ::GraphQL::Schema::_Type
         attr_reader grouping_missing_value_placeholder: ::String? | ::Numeric?
         def search_index_definitions: () -> ::Array[DatastoreCore::_IndexDefinition]
+        def source_type: () -> Type
+        def subtypes: () -> ::Array[Type]
+        def non_subtypes_in_shared_index: () -> ::Set[Type]
         def unwrap_fully: () -> Type
         def field_named: (::String) -> Field
         def fields_by_name_in_index: () -> ::Hash[::String, ::Array[Field]]

elasticgraph-graphql/spec/unit/elastic_graph/graphql/schema/type_spec.rb

@@ -758,6 +758,87 @@ def search_index_definitions_from(type_name: "TheType")
           end
         end
 
+        describe "#source_type" do
+          it "returns the underlying document type for an indexed aggregation type" do
+            schema = define_schema do |s|
+              s.object_type "Thing" do |t|
+                t.field "id", "ID!"
+                t.index "things"
+              end
+            end
+
+            aggregation_type = schema.type_named("ThingAggregation")
+            expect(aggregation_type.source_type).to be schema.type_named("Thing")
+          end
+
+          it "returns self for a non-derived type" do
+            schema = define_schema do |s|
+              s.object_type "Thing" do |t|
+                t.field "id", "ID!"
+                t.index "things"
+              end
+            end
+
+            thing_type = schema.type_named("Thing")
+            expect(thing_type.source_type).to be thing_type
+          end
+        end
+
+        describe "#non_subtypes_in_shared_index" do
+          attr_reader :schema
+
+          before(:context) do
+            @schema = define_schema(clients_by_name: {}) do |s|
+              # A root interface with an index shared by all sub-hierarchies.
+              s.interface_type "Channel" do |t|
+                t.field "id", "ID!"
+                t.index "channels"
+              end
+
+              # A sibling type — NOT under Store, but shares the Channel index.
+              s.object_type "Wholesaler" do |t|
+                t.implements "Channel"
+                t.field "id", "ID!"
+              end
+
+              # A sub-interface and its concrete subtypes.
+              s.interface_type "Store" do |t|
+                t.implements "Channel"
+                t.field "id", "ID!"
+              end
+
+              s.object_type "OnlineStore" do |t|
+                t.implements "Store"
+                t.field "id", "ID!"
+              end
+
+              # PhysicalStore overrides to use a dedicated index.
+              s.object_type "PhysicalStore" do |t|
+                t.implements "Store"
+                t.field "id", "ID!"
+                t.index "physical_stores"
+              end
+            end
+          end
+
+          it "excludes the type itself and its subtypes" do
+            store = schema.type_named("Store")
+
+            result = store.non_subtypes_in_shared_index
+            expect(result).not_to include(store)
+            expect(result).not_to include(schema.type_named("OnlineStore"))
+            expect(result).not_to include(schema.type_named("PhysicalStore"))
+          end
+
+          it "includes concrete sibling types that share the same index" do
+            expect(schema.type_named("Store").non_subtypes_in_shared_index).to include(schema.type_named("Wholesaler"))
+          end
+
+          it "returns an empty set when all types sharing its indexes are subtypes" do
+            expect(schema.type_named("Channel").non_subtypes_in_shared_index).to be_empty
+          end
+        end
+
         describe "#hidden_from_queries?" do
           it "returns `false` on a type that has no backing indexed types" do
             schema = define_schema do |s|