Address more PR review feedback on GraphQL::Schema::Type helpers

- `source_type`: use `defined?(@source_type)` pattern to correctly memoize
  nil return values (||= doesn't memoize nil)
- Rename `non_subtypes_in_shared_index` → `concrete_non_subtypes_in_shared_index`
  to make explicit that abstract types are excluded from the result
- Tests: add a second sibling type so at least one test returns multiple
  elements, making it harder for a partial implementation to pass

Generated with Claude Code

Author: marcdaniels-toast

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

@@ -131,18 +131,19 @@ def subtypes
         # For derived types (e.g. indexed aggregations), returns the underlying source document type.
         # Returns `nil` for non-derived types.
         def source_type
-          @source_type ||= @object_runtime_metadata&.source_type&.then { |st| @schema.type_named(st) }
+          return @source_type if defined?(@source_type)
+          @source_type = @object_runtime_metadata&.source_type&.then { |st| @schema.type_named(st) }
         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.
+        # Returns the set of concrete (non-abstract) 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 ||=
+        def concrete_non_subtypes_in_shared_index
+          @concrete_non_subtypes_in_shared_index ||=
             search_index_definitions
               .flat_map { |index_def| @schema.document_types_stored_in(index_def.name).to_a }
               .reject { |t| t == self || subtypes.include?(t) || t.abstract? }

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

@@ -11,7 +11,7 @@ module ElasticGraph
         def search_index_definitions: () -> ::Array[DatastoreCore::_IndexDefinition]
         def source_type: () -> Type?
         def subtypes: () -> ::Set[Type]
-        def non_subtypes_in_shared_index: () -> ::Set[Type]
+        def concrete_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

@@ -793,7 +793,7 @@ def search_index_definitions_from(type_name: "TheType")
           end
         end
 
-        describe "#non_subtypes_in_shared_index" do
+        describe "#concrete_non_subtypes_in_shared_index" do
           attr_reader :schema
 
           before(:context) do
@@ -804,12 +804,17 @@ def search_index_definitions_from(type_name: "TheType")
                 t.index "channels"
               end
 
-              # A sibling type — NOT under Store, but shares the Channel index.
+              # Sibling types — NOT under Store, but share the Channel index.
               s.object_type "Wholesaler" do |t|
                 t.implements "Channel"
                 t.field "id", "ID!"
               end
 
+              s.object_type "Distributor" 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"
@@ -831,17 +836,23 @@ def search_index_definitions_from(type_name: "TheType")
           end
 
           it "excludes the type itself and its subtypes, returning only concrete sibling types in the shared index" do
-            expect(schema.type_named("Store").non_subtypes_in_shared_index).to contain_exactly(schema.type_named("Wholesaler"))
+            expect(schema.type_named("Store").concrete_non_subtypes_in_shared_index).to contain_exactly(
+              schema.type_named("Wholesaler"),
+              schema.type_named("Distributor")
+            )
           end
 
           it "excludes the type itself even when the type is a concrete type in a shared index" do
             # Wholesaler is a concrete type stored in the "channels" index, so it appears in
             # document_types_stored_in("channels"). Without the `t == self` guard it would include itself.
-            expect(schema.type_named("Wholesaler").non_subtypes_in_shared_index).to contain_exactly(schema.type_named("OnlineStore"))
+            expect(schema.type_named("Wholesaler").concrete_non_subtypes_in_shared_index).to contain_exactly(
+              schema.type_named("Distributor"),
+              schema.type_named("OnlineStore")
+            )
           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
+            expect(schema.type_named("Channel").concrete_non_subtypes_in_shared_index).to be_empty
           end
         end