elasticgraph-schema_definition 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b581d94dc4105d042776cd08fc1a0b4968840a723a06de483f51276eaaa4d2f
-  data.tar.gz: d00543cabfa2cb9bbdbc225de3224cd16adee14fe50a559da63299deff50b658
+  metadata.gz: 2d7df929fabb0ebf9ed6bbee5aa2c981b0baf94fd43c6df151ff84b02345a347
+  data.tar.gz: 5b1501454d93320f48648c43087b85594a6aae6391333fdd269fda890a5304f3
 SHA512:
-  metadata.gz: b93e0ae17db9cb462e2e11a590965a6a4fe7a3e240eee8cf3042fc174ed8d933641e6f3adc5618ca816d9cba88fa944ff9f5541e97d5f7b3a4b68fa832e365d9
-  data.tar.gz: eefd1fa67fdf00e33eddb7b128953a0bf301d57894367be7b0dd525b67237e439ff239e40373e8a958d02dcc3b417c1a5f080ac72796146e1a0c29da136ad422
+  metadata.gz: 8ded763f8bb207d76500090a965206fbdb729c6ed70fe9b83d56e09f8d983f21f523da0e80af54164a7891c2c29bff482f1ca56f9f89fa694f9f865fcd7691ce
+  data.tar.gz: 8d95ee2401637317cccd9f84937f19e229eb7d2e01e63b44682308c3032b302a7caf21c2c0f1971746535e04354fdbf48c2050b5879a59a2efe0217f96c8a1a8

data/README.md

@@ -30,9 +30,6 @@ graph LR;
     graphql["graphql"];
     elasticgraph-schema_definition --> graphql;
     class graphql externalGemStyle;
-    graphql-c_parser["graphql-c_parser"];
-    elasticgraph-schema_definition --> graphql-c_parser;
-    class graphql-c_parser externalGemStyle;
     rake["rake"];
     elasticgraph-schema_definition --> rake;
     class rake externalGemStyle;
@@ -40,7 +37,6 @@ graph LR;
     elasticgraph-local --> elasticgraph-schema_definition;
     class elasticgraph-local otherEgGemStyle;
     click graphql href "https://rubygems.org/gems/graphql" "Open on RubyGems.org" _blank;
-    click graphql-c_parser href "https://rubygems.org/gems/graphql-c_parser" "Open on RubyGems.org" _blank;
     click rake href "https://rubygems.org/gems/rake" "Open on RubyGems.org" _blank;
 ```
 

data/lib/elastic_graph/schema_definition/api.rb

@@ -13,6 +13,10 @@ require "elastic_graph/schema_definition/mixins/has_readable_to_s_and_inspect"
 require "elastic_graph/schema_definition/results"
 require "elastic_graph/schema_definition/state"
 
+# :nocov: -- only loaded on JRuby
+require "elastic_graph/schema_definition/jruby_patches" if RUBY_ENGINE == "jruby"
+# :nocov:
+
 module ElasticGraph
   # The main entry point for schema definition from ElasticGraph applications.
   #
@@ -135,6 +139,10 @@ module ElasticGraph
       # one or more fields that concrete implementations of the interface must also define. Each implementation can be an
       # {SchemaElements::ObjectType} or {SchemaElements::InterfaceType}.
       #
+      # @note An interface type can declare an index with {Mixins::HasIndices#index}. This creates a _mixed-type index_ in
+      #   the datastore where concrete types that implement the interface coexist. A subtype may opt out of this shared
+      #   index inheritance and use a dedicated index by declaring its own with {Mixins::HasIndices#index}.
+      #
       # @param name [String] name of the interface
       # @yield [SchemaElements::InterfaceType] interface type object
       # @return [void]
@@ -199,6 +207,10 @@ module ElasticGraph
       # Defines a [GraphQL union type](https://graphql.org/learn/schema/#union-types). Use it to define an abstract supertype with one or
       # more concrete subtypes. Each subtype must be an {SchemaElements::ObjectType}, but they do not have to share any fields in common.
       #
+      # @note A union type can declare an index with {Mixins::HasIndices#index}. This creates a _mixed-type index_ in
+      #   the datastore where the union members coexist. A subtype may opt out of this shared index inheritance and use
+      #   a dedicated index by declaring its own with {Mixins::HasIndices#index}.
+      #
       # @param name [String] name of the union type
       # @yield [SchemaElements::UnionType] union type object
       # @return [void]
@@ -298,6 +310,8 @@ module ElasticGraph
       # @param name [Symbol] unique name of the resolver
       # @param klass [Class] resolver class
       # @param defined_at [String] the `require` path of the resolver
+      # @param built_in [bool] Whether this resolver is built-in to ElasticGraph or one of its extensions.
+      #   Built-in resolvers that are unused in a schema will not trigger a warning.
       # @param resolver_config [Hash<Symbol, Object>] configuration options for the resolver, to support parameterized resolvers
       # @return [void]
       # @see Mixins::HasIndices#resolve_fields_with
@@ -365,7 +379,7 @@ module ElasticGraph
       #       end
       #     end
       #   end
-      def register_graphql_resolver(name, klass, defined_at:, **resolver_config)
+      def register_graphql_resolver(name, klass, defined_at:, built_in: false, **resolver_config)
         extension = SchemaArtifacts::RuntimeMetadata::Extension.new(klass, defined_at, resolver_config)
 
         needs_lookahead =
@@ -382,6 +396,11 @@ module ElasticGraph
         )
 
         @state.graphql_resolvers_by_name[name] = resolver
+        if built_in
+          @state.built_in_graphql_resolvers << name
+        else
+          @state.built_in_graphql_resolvers.delete(name)
+        end
         nil
       end
 

data/lib/elastic_graph/schema_definition/factory.rb

@@ -17,7 +17,7 @@ require "elastic_graph/schema_definition/schema_elements/deprecated_element"
 require "elastic_graph/schema_definition/schema_elements/directive"
 require "elastic_graph/schema_definition/schema_elements/enum_type"
 require "elastic_graph/schema_definition/schema_elements/enum_value"
-require "elastic_graph/schema_definition/schema_elements/enums_for_indexed_types"
+require "elastic_graph/schema_definition/schema_elements/enums_for_directly_queryable_types"
 require "elastic_graph/schema_definition/schema_elements/field"
 require "elastic_graph/schema_definition/schema_elements/field_source"
 require "elastic_graph/schema_definition/schema_elements/graphql_sdl_enumerator"
@@ -106,10 +106,10 @@ module ElasticGraph
       end
       @@enum_value_new = prevent_non_factory_instantiation_of(SchemaElements::EnumValue)
 
-      def new_enums_for_indexed_types
-        @@enums_for_indexed_types_new.call(@state)
+      def new_enums_for_directly_queryable_types
+        @@enums_for_directly_queryable_types_new.call(@state)
       end
-      @@enums_for_indexed_types_new = prevent_non_factory_instantiation_of(SchemaElements::EnumsForIndexedTypes)
+      @@enums_for_directly_queryable_types_new = prevent_non_factory_instantiation_of(SchemaElements::EnumsForDirectlyQueryableTypes)
 
       # Hard to type check this.
       # @dynamic new_field
@@ -489,7 +489,7 @@ module ElasticGraph
             EOS
           end
 
-          if object_type&.indexed?
+          if object_type&.root_document_type?
             t.field @state.schema_elements.all_highlights, "[SearchHighlight!]!" do |f|
               f.documentation "All search highlights for this `#{type_name}`, indicating where in the indexed document the query matched."
             end

data/lib/elastic_graph/schema_definition/indexing/derived_fields/min_or_max_value.rb

@@ -62,7 +62,7 @@ module ElasticGraph
                   coercedCurrentFieldValue = (currentFieldValue instanceof Number) ? ((Number)currentFieldValue).longValue() : currentFieldValue;
                 }
 
-                if (coercedCurrentFieldValue == null || (#{min_or_max}NewValue != null && #{min_or_max}NewValue.compareTo(coercedCurrentFieldValue) #{operator} 0)) {
+                if (#{min_or_max}NewValue != null && (coercedCurrentFieldValue == null || #{min_or_max}NewValue.compareTo(coercedCurrentFieldValue) #{operator} 0)) {
                   parentObject[fieldName] = #{min_or_max}NewValue;
                   return true;
                 }

data/lib/elastic_graph/schema_definition/indexing/event_envelope.rb

@@ -54,8 +54,11 @@ module ElasticGraph
                 "type" => "object",
                 "additionalProperties" => false,
                 "patternProperties" => {
-                  "description" => "A timestamp from which ElasticGraph will measure indexing latency. The timestamp name must end in `_at`.",
-                  "^\\w+_at$" => {"type" => "string", "format" => "date-time"}
+                  "^\\w+_at$" => {
+                    "description" => "A timestamp from which ElasticGraph will measure indexing latency. The timestamp name must end in `_at`.",
+                    "type" => "string",
+                    "format" => "date-time"
+                  }
                 }
               },
               JSON_SCHEMA_VERSION_KEY => {

data/lib/elastic_graph/schema_definition/indexing/index.rb

@@ -63,7 +63,9 @@ module ElasticGraph
             # By using it here, it will cause queries to pass a `routing` parameter when
             # searching with id filtering on an index that does not use custom shard routing, giving
             # us a nice efficiency boost.
-            self.routing_field_path = public_field_path("id", explanation: "indexed types must have an `id` field")
+            id_field_path = public_field_path("id", explanation: "indexed types must have an `id` field")
+            self.routing_field_path = id_field_path
+            id_field_path.last_part.json_schema nullable: false
           end
 
           yield self if block_given?
@@ -295,7 +297,7 @@ module ElasticGraph
             .except("type") # `type` is invalid at the mapping root because it always has to be an object.
             .then { |mapping| ListCountsMapping.merged_into(mapping, for_type: indexed_type) }
             .then do |fm|
-              Support::HashUtil.deep_merge(fm, {"properties" => {
+              internal_fields = {
                 "__sources" => {"type" => "keyword"},
                 "__versions" => {
                   "type" => "object",
@@ -315,7 +317,17 @@ module ElasticGraph
                   # a boolean.
                   "dynamic" => "false"
                 }
-              }})
+              }
+
+              # We add __typename for concrete types so they can be matched by __typename filters, which are
+              # applied when querying abstract types that span multiple indices. Since every document in a
+              # concrete type's index has the same value, we use constant_keyword here. It stores __typename
+              # once at the index level with zero per-document overhead.
+              unless indexed_type.abstract?
+                internal_fields["__typename"] = {"type" => "constant_keyword", "value" => indexed_type.name}
+              end
+
+              Support::HashUtil.deep_merge(fm, {"properties" => internal_fields})
             end
 
           {"dynamic" => "strict"}.merge(field_mappings).tap do |hash|
@@ -324,6 +336,12 @@ module ElasticGraph
             # made against the wrong shard.
             hash["_routing"] = {"required" => true} if uses_custom_routing?
             hash["_size"] = {"enabled" => true} if schema_def_state.index_document_sizes?
+
+            # Exclude non-returnable fields from `_source` to save storage. These fields are still
+            # indexed (in the inverted index and/or doc_values) for filtering, sorting, and aggregation,
+            # but their values are not stored in the compressed `_source` blob.
+            source_excludes = indexed_type.source_excludes_paths
+            hash["_source"] = {"excludes" => source_excludes} if source_excludes.any?
           end
         end
 

data/lib/elastic_graph/schema_definition/indexing/json_schema_with_metadata.rb

@@ -156,15 +156,15 @@ module ElasticGraph
             json_schema_resolver = JSONSchemaResolver.new(@state, json_schema, old_type_name_by_current_name)
             version = json_schema.fetch(JSON_SCHEMA_VERSION_KEY)
 
-            types_to_check = @state.object_types_by_name.values.select do |type|
-              type.indexed? && !@derived_indexing_type_names.include?(type.name)
-            end
-
-            types_to_check.filter_map do |object_type|
-              if (index_def = object_type.index_def)
-                identify_missing_necessary_fields_for_index_def(object_type, index_def, json_schema_resolver, version)
+            @state.object_types_by_name.values
+              .select { |type| type.has_own_index_def? && !@derived_indexing_type_names.include?(type.name) }
+              .flat_map do |object_type|
+                identify_missing_necessary_fields_for_index_def(
+                  object_type,
+                  object_type.own_index_def, # : Indexing::Index
+                  json_schema_resolver, version
+                )
               end
-            end.flatten
           end
 
           def identify_missing_necessary_fields_for_index_def(object_type, index_def, json_schema_resolver, json_schema_version)

data/lib/elastic_graph/schema_definition/indexing/relationship_resolver.rb

@@ -34,8 +34,8 @@ module ElasticGraph
               end
 
             [nil, "#{relationship_error_prefix} #{issue}"]
-          elsif !related_type.indexed?
-            [nil, "#{relationship_error_prefix} references a type which is not indexed: `#{related_type.name}`. Only indexed types can be used in relations."]
+          elsif !related_type.root_document_type?
+            [nil, "#{relationship_error_prefix} references a type which is not a root document type: `#{related_type.name}`. Only root document types can be used in relations."]
           else
             relation_metadata = relation_field.runtime_metadata_graphql_field.relation # : SchemaArtifacts::RuntimeMetadata::Relation
             foreign_key_parent_type = (relation_metadata.direction == :in) ? related_type : object_type

data/lib/elastic_graph/schema_definition/indexing/update_target_resolver.rb

@@ -137,7 +137,7 @@ module ElasticGraph
         #
         # Returns a tuple of the resolved source (if successful) and an error (if invalid).
         def resolve_field_source(adapter)
-          index_def = object_type.index_def # : Index
+          index_def = object_type.own_index_def # : Index
 
           field_source_graphql_path_string = adapter.get_field_source(resolved_relationship.relationship, index_def) do |local_need|
             relationship_name = resolved_relationship.relationship_name

data/lib/elastic_graph/schema_definition/jruby_patches.rb

@@ -0,0 +1,59 @@
+# Copyright 2024 - 2026 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+# Central location for JRuby workarounds in the schema_definition gem.
+# Each patch should reference the upstream fix and specify when it can be removed.
+
+module ElasticGraph
+  module SchemaDefinition
+    # @private
+    module JRubyPatches
+      # Bug: `Thread::Backtrace::Location#absolute_path` returns a relative path (same as `#path`)
+      # when the source file was loaded via `load` with a bare relative path (e.g. `load "schema.rb"`).
+      # On MRI, `absolute_path` correctly resolves to the full absolute path in this case.
+      # Workaround: override `absolute_path` to expand relative paths.
+      # Reported upstream: https://github.com/jruby/jruby/issues/9245
+      # TODO: remove once JRuby fixes this upstream.
+      # @private
+      module BacktraceLocationAbsolutePathPatch
+        def absolute_path
+          result = super
+          return result if result.nil? || result.start_with?("/")
+          ::File.expand_path(result)
+        end
+      end
+
+      ::Thread::Backtrace::Location.class_exec do
+        prepend BacktraceLocationAbsolutePathPatch
+      end
+    end
+  end
+end
+
+require "elastic_graph/schema_definition/mixins/verifies_graphql_name"
+require "elastic_graph/schema_definition/mixins/has_indices"
+
+# Bug: `def initialize(...)` + `super(...)` (or `super(*args, **kwargs)`) in a module
+# prepended/included on a Struct subclass incorrectly warns about keyword arguments
+# (3+ members) or crashes with ClassCastException (1 member).
+# Workaround: use `ruby2_keywords` to avoid separate `**kwargs` forwarding.
+# Reported upstream: https://github.com/jruby/jruby/issues/9242
+# TODO: remove once JRuby fixes this upstream.
+ElasticGraph::SchemaDefinition::Mixins::VerifiesGraphQLName.class_exec do
+  ruby2_keywords def initialize(*args, &block)
+    super(*args, &block)
+    ::ElasticGraph::SchemaDefinition::Mixins::VerifiesGraphQLName.verify_name!(name)
+  end
+end
+
+ElasticGraph::SchemaDefinition::Mixins::HasIndices.class_exec do
+  ruby2_keywords def initialize(*args, &block)
+    super(*args, &block)
+    initialize_has_indices { yield self }
+  end
+end

data/lib/elastic_graph/schema_definition/mixins/has_indices.rb

@@ -26,19 +26,18 @@ module ElasticGraph
         # @private
         def initialize(*args, **options)
           super(*args, **options)
-          @runtime_metadata_overrides = {}
-          @can_configure_index = true
-          resolve_fields_with :get_record_field_value
-          yield self
-          @can_configure_index = false
+          initialize_has_indices { yield self }
         end
 
-        # Converts the current type from being an _embedded_ type (that is, a type that is embedded within another indexed type) to an
-        # _indexed_ type that resides in the named index definition. Indexed types are directly indexed into the datastore, and will be
-        # queryable from the root `Query` type.
+        # Declares a datastore index for the current type, converting it from an _embedded_ type to an _indexed_ type
+        # that is directly queryable from the root `Query` type. When called on an abstract `interface_type` or
+        # `union_type`, concrete subtypes inherit the index by default — they share the same datastore index without
+        # needing to call `t.index` themselves. A subtype can opt out of this shared index inheritance by calling
+        # `t.index` with a different name to use a dedicated index instead.
         #
         # @note Use {#root_query_fields} on indexed types to name the field that will be exposed on `Query`.
         # @note Indexed types must also define an `id` field, which ElasticGraph will use as the primary key.
+        #   When an abstract type declares the index, each concrete subtype must also define `id`.
         # @note Datastore index settings can also be defined (or overridden) in an environment-specific settings YAML file. Index settings
         #   that you want to configure differently for different environments (such as `index.number_of_shards`—-production and staging
         #   will probably need different numbers!) should be configured in the per-environment YAML configuration files rather than here.
@@ -50,7 +49,7 @@ module ElasticGraph
         # @yield [Indexing::Index] the index, so it can be customized further
         # @return [void]
         #
-        # @example Define a `campaigns` index
+        # @example Define a `campaigns` index on a concrete type
         #   ElasticGraph.define_schema do |schema|
         #     schema.object_type "Campaign" do |t|
         #       t.field "id", "ID"
@@ -66,18 +65,45 @@ module ElasticGraph
         #       end
         #     end
         #   end
+        #
+        # @example Declare a shared index on an interface
+        #   ElasticGraph.define_schema do |schema|
+        #     schema.interface_type "Vehicle" do |t|
+        #       t.field "id", "ID"
+        #       t.field "make", "String"
+        #       t.index "vehicles"
+        #     end
+        #
+        #     schema.object_type "Car" do |t|
+        #       t.implements "Vehicle"
+        #       t.field "id", "ID"
+        #       t.field "make", "String"
+        #       t.field "numDoors", "Int"
+        #       # Inherits the `vehicles` index — no need to call `t.index`.
+        #     end
+        #
+        #     schema.object_type "Motorcycle" do |t|
+        #       t.implements "Vehicle"
+        #       t.field "id", "ID"
+        #       t.field "make", "String"
+        #       t.field "engineCC", "Int"
+        #       # Opts out of the shared index and gets its own dedicated index instead.
+        #       t.index "motorcycles"
+        #     end
+        #   end
         def index(name, **settings, &block)
           unless @can_configure_index
             raise Errors::SchemaError, "Cannot define an index on `#{self.name}` after initialization is complete. " \
               "Indices must be configured during initial type definition."
           end
 
-          if @index_def
+          if @own_index_def
             raise Errors::SchemaError, "Cannot define multiple indices on `#{self.name}`. " \
-              "Only one index per type is supported. An index named `#{@index_def.name}` has already been defined."
+              "Only one index per type is supported. An index named `#{@own_index_def.name}` has already been defined."
           end
 
-          @index_def = schema_def_state.factory.new_index(name, settings, self, &block)
+          schema_def_state.register_index(name, self)
+          @own_index_def = schema_def_state.factory.new_index(name, settings, self, &block)
         end
 
         # Configures the default GraphQL resolver that will be used to resolve the fields of this type. Individual fields
@@ -93,14 +119,54 @@ module ElasticGraph
           end
         end
 
-        # @return [Indexing::Index, nil] the defined index for this type, or nil if no index is defined
+        # @return [Indexing::Index, nil] the index definition directly defined on this type, or nil if no index is defined directly.
+        #   This will be nil when a type is inheriting an index definition from an abstract parent type.
+        def own_index_def
+          @own_index_def
+        end
+
+        # @return [Boolean] true if this type has its own index definition (not inherited from an abstract parent)
+        def has_own_index_def?
+          !@own_index_def.nil?
+        end
+
+        # Resolves this type's index definition. This will be one of:
+        # - This type's own_index_def (if it directly defines an index)
+        # - An inherited index from an abstract supertype (union/interface) that has an index
+        #
+        # This type can be a subtype of multiple abstract types (e.g., implements multiple interfaces), but unless it
+        # defines its own index, at most one of its supertypes may have an index. If multiple parent types are indexed,
+        # this method raises an error to prevent ambiguity about which index to inherit.
+        #
+        # @return [Indexing::Index, nil] the index definition, or nil if this type has no index
+        # @raise [Errors::SchemaError] if this type is a subtype of multiple indexed abstract types
         def index_def
-          @index_def
+          return own_index_def if has_own_index_def?
+
+          indexed_supertypes = recursively_resolve_supertypes.select(&:has_own_index_def?)
+
+          if indexed_supertypes.size > 1
+            parent_names = indexed_supertypes.map { |p| p.own_index_def.name }.join(", ")
+            raise Errors::SchemaError,
+              "The `#{name}` type is a subtype of multiple indexed abstract types (#{parent_names}). " \
+              "If a concrete type does not define an index, it may not be a member of multiple indexed abstract types."
+          end
+
+          indexed_supertypes.first&.own_index_def
+        end
+
+        # @return [Boolean] true if this type is a root document type that lives at a document root in the datastore (is indexed).
+        #   This returns true for types with their own index definition or types that inherit an index from a supertype.
+        def root_document_type?
+          !index_def.nil?
         end
 
-        # @return [Boolean] true if this type has an index
-        def indexed?
-          !@index_def.nil?
+        # @return [Boolean] true if this type is directly queryable via a type-specific field on the root `Query` type.
+        # @note A concrete subtype that inherits an index from an abstract parent is NOT directly queryable on its own —
+        #   only the abstract type that declared the index is. Use {#root_document_type?} to check whether a type
+        #   is stored at the root of any index (own or inherited).
+        def directly_queryable?
+          has_own_index_def?
         end
 
         # Abstract types are rare, so return false. This can be overridden in the host class.
@@ -259,10 +325,48 @@ module ElasticGraph
           indexing_fields_by_name_in_index.values.reject { |f| f.source.nil? }
         end
 
+        # Returns the list of `_source.excludes` paths for non-returnable, non-highlightable fields.
+        #
+        # Hidden highlightable fields must remain in `_source` so the datastore can still
+        # produce search highlight snippets for them.
+        #
+        # Uses `indexing_fields_by_name_in_index` for traversal (same as
+        # `index_field_runtime_metadata_tuples`) to avoid infinite recursion
+        # through interface/union subtype cycles.
+        #
+        # @private
+        def source_excludes_paths(path_prefix = "", under_non_returnable_parent = false)
+          indexing_fields_by_name_in_index.flat_map do |name, field|
+            path = path_prefix + name
+            object_type = field.type.fully_unwrapped.as_object_type
+            non_returnable = under_non_returnable_parent || !field.returnable?
+
+            if object_type
+              if non_returnable && !field.highlightable?
+                ["#{path}.*"]
+              else
+                object_type.source_excludes_paths("#{path}.", non_returnable)
+              end
+            elsif non_returnable && !field.highlightable?
+              [path]
+            else
+              []
+            end
+          end
+        end
+
         private
 
+        def initialize_has_indices
+          @runtime_metadata_overrides = {}
+          @can_configure_index = true
+          resolve_fields_with :get_record_field_value
+          yield
+          @can_configure_index = false
+        end
+
         def self_update_target
-          return nil if abstract? || !indexed?
+          return nil if abstract? || !root_document_type?
 
           # We exclude `id` from `data_params` because `Indexer::Operator::Update` automatically includes
           # `params.id` so we don't want it duplicated at `params.data.id` alongside other data params.

data/lib/elastic_graph/schema_definition/mixins/has_subtypes.rb

@@ -34,8 +34,15 @@ module ElasticGraph
             .merge("__typename" => schema_def_state.factory.new_field(name: "__typename", type: "String", parent_type: _ = self))
         end
 
-        def indexed?
-          super || subtypes_indexed?
+        def root_document_type?
+          super || subtypes_are_root_document_types?
+        end
+
+        # An abstract type is queryable if all of its subtypes are root document types (via a direct or inherited index)
+        # even if those subtypes aren't themselves directly queryable. This is why this doesn't delegate to a
+        # subtypes_are_directly_queryable helper.
+        def directly_queryable?
+          super || subtypes_are_root_document_types?
         end
 
         def recursively_resolve_subtypes
@@ -90,26 +97,28 @@ module ElasticGraph
           end
         end
 
-        def subtypes_indexed?
-          indexed_by_subtype_name = resolve_subtypes.to_h do |subtype, acc|
-            [subtype.name, subtype.indexed?]
+        def subtypes_are_root_document_types?
+          root_document_type_by_subtype_name = resolve_subtypes.to_h do |subtype, acc|
+            [subtype.name, subtype.root_document_type?]
           end
 
-          uniq_indexed = indexed_by_subtype_name.values.uniq
+          uniq_root_document_type_vals = root_document_type_by_subtype_name.values.uniq
 
-          if uniq_indexed.size > 1
-            descriptions = indexed_by_subtype_name.map do |name_value|
+          if uniq_root_document_type_vals.size > 1
+            descriptions = root_document_type_by_subtype_name.map do |name_value|
               name, value = name_value
-              "#{name}: indexed? = #{value}"
+              "#{name}: root_document_type? = #{value}"
             end
 
             raise Errors::SchemaError,
-              "The #{self.class.name} #{name} has some indexed subtypes, and some non-indexed subtypes. " \
-              "All subtypes must be indexed or all must NOT be indexed. Subtypes:\n" \
+              "The #{self.class.name} #{name} has some subtypes that are root document types, and some that are not. " \
+              "All subtypes must be root document types or all must NOT be root document types. " \
+              "(A type is a root document type when it has an index definition or, for abstract types, when its subtypes have index definitions.) " \
+              "Subtypes:\n" \
               "#{descriptions.join("\n")}"
           end
 
-          !!uniq_indexed.first
+          !!uniq_root_document_type_vals.first
         end
       end
     end

data/lib/elastic_graph/schema_definition/mixins/implements_interfaces.rb

@@ -16,6 +16,10 @@ module ElasticGraph
         # Declares that the current type implements the specified interface, making the current type a subtype of the interface. The
         # current type must define all of the fields of the named interface, with the exact same field types.
         #
+        # @note If the named interface has declared an index (via {Mixins::HasIndices#index}), calling `implements`
+        #   causes this type to automatically inherit that index — it will be stored in the same datastore index as all other
+        #   implementations of the named interface. To use a dedicated index instead, call {Mixins::HasIndices#index} on this type.
+        #
         # @param interface_names [Array<String>] names of interface types implemented by this type
         # @return [void]
         #
@@ -112,11 +116,38 @@ module ElasticGraph
             if implemented_interfaces.empty?
               name
             else
-              "#{name} implements #{implemented_interfaces.join(" & ")}"
+              # Include all ancestor interfaces in SDL
+              all_interfaces = recursively_resolve_supertypes.grep(SchemaElements::InterfaceType)
+              "#{name} implements #{all_interfaces.map(&:name).sort.join(" & ")}"
             end
 
           generate_sdl(name_section: name_section, &field_arg_selector)
         end
+
+        # Returns all supertypes of this type, including union memberships and interface ancestors.
+        #
+        # @return [Set<UnionType, InterfaceType>] set of supertypes
+        # @private
+        def recursively_resolve_supertypes
+          union_memberships = schema_def_state.union_types_by_member_ref[type_ref] # : ::Set[abstractType]
+          union_memberships | recursively_resolve_interface_supertypes
+        end
+
+        private
+
+        def recursively_resolve_interface_supertypes(ancestors: Set.new)
+          implemented_interfaces.flat_map do |interface_ref|
+            interface = interface_ref.resolved # : SchemaElements::InterfaceType
+
+            if ancestors.include?(interface)
+              raise Errors::SchemaError, "Your schema has self-referential types, which are not allowed, since " \
+                "it prevents the datastore mapping and GraphQL schema generation from terminating:\n" \
+                "- There is a circular reference chain involving #{(ancestors.map(&:name) + [interface_ref.name]).sort.inspect}."
+            end
+
+            [interface] + interface.send(:recursively_resolve_interface_supertypes, ancestors: ancestors | [interface])
+          end
+        end
       end
     end
   end

data/lib/elastic_graph/schema_definition/mixins/supports_default_value.rb

@@ -12,14 +12,7 @@ module ElasticGraph
   module SchemaDefinition
     module Mixins
       # A mixin designed to be included in a schema element class that supports default values.
-      # Designed to be `prepended` so that it can hook into `initialize`.
       module SupportsDefaultValue
-        # @private
-        def initialize(...)
-          __skip__ = super # steep can't type this.
-          @default_value = NO_DEFAULT_PROVIDED
-        end
-
         # Used to specify the default value for this field or argument.
         #
         # @param default_value [Object] default value for this field or argument
@@ -32,15 +25,9 @@ module ElasticGraph
         #
         # @return [String]
         def default_value_sdl
-          return nil if @default_value == NO_DEFAULT_PROVIDED
+          return nil unless instance_variable_defined?(:@default_value)
           " = #{Support::GraphQLFormatter.serialize(@default_value)}"
         end
-
-        private
-
-        # A sentinel value that we can use to detect when a default has been provided.
-        # We can't use `nil` to detect if a default has been provided because `nil` is a valid default value!
-        NO_DEFAULT_PROVIDED = Module.new
       end
     end
   end