elasticgraph-schema_definition 1.1.0 → 1.2.0

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

@@ -33,7 +33,7 @@ module ElasticGraph
         def derived_graphql_types
           return [] if graphql_only?
 
-          indexed_agg_type = to_indexed_aggregation_type
+          indexed_agg_type = to_root_aggregation_type
           indexed_aggregation_pagination_types =
             if indexed_agg_type
               schema_def_state.factory.build_relay_pagination_types(indexed_agg_type.name)
@@ -51,7 +51,7 @@ module ElasticGraph
           end
 
           document_pagination_types =
-            if indexed?
+            if directly_queryable?
               schema_def_state.factory.build_relay_pagination_types(name, include_total_edge_count: true, derived_indexed_types: (_ = self).derived_indexed_types)
             elsif schema_def_state.paginated_collection_element_types.include?(name)
               schema_def_state.factory.build_relay_pagination_types(name, include_total_edge_count: true)
@@ -59,7 +59,7 @@ module ElasticGraph
               [] # : ::Array[SchemaElements::ObjectType]
             end
 
-          sort_order_enum_type = schema_def_state.enums_for_indexed_types.sort_order_enum_for(self)
+          sort_order_enum_type = schema_def_state.enums_for_directly_queryable_types.sort_order_enum_for(self)
           derived_sort_order_enum_types = [sort_order_enum_type].compact + (sort_order_enum_type&.derived_graphql_types || [])
 
           to_input_filters +
@@ -87,6 +87,17 @@ module ElasticGraph
           return [] if does_not_support?(&:filterable?)
 
           schema_def_state.factory.build_standard_filter_input_types_for_index_object_type(name) do |t|
+            if abstract?
+              t.field schema_def_state.schema_elements._typename, schema_def_state.type_ref("String").as_filter_input.name, name_in_index: "__typename" do |f|
+                f.documentation <<~EOS
+                  Filters `#{name}` records by concrete type. Only concrete type names are valid values —
+                  filtering on an abstract type name will match nothing, since records only have concrete
+                  type names for their `__typename` value.
+                  Analogous to the `__typename` return field.
+                EOS
+              end
+            end
+
             graphql_fields_by_name.values.each do |field|
               if field.filterable?
                 t.graphql_fields_by_name[field.name] = field.to_filter_field(parent_type: t)
@@ -198,8 +209,8 @@ module ElasticGraph
           end
         end
 
-        def to_indexed_aggregation_type
-          return nil unless indexed?
+        def to_root_aggregation_type
+          return nil unless directly_queryable?
 
           schema_def_state.factory.new_object_type type_ref.as_aggregation.name do |t|
             t.documentation "Return type representing a bucket of `#{name}` documents for an aggregations query."

data/lib/elastic_graph/schema_definition/rake_tasks.rb

@@ -171,18 +171,20 @@ module ElasticGraph
       end
 
       def schema_def_api
-        require "elastic_graph/schema_definition/api"
+        @schema_def_api ||= begin
+          require "elastic_graph/schema_definition/api"
 
-        API.new(
-          @schema_element_names,
-          @index_document_sizes,
-          extension_modules: @extension_modules,
-          derived_type_name_formats: @derived_type_name_formats,
-          type_name_overrides: @type_name_overrides,
-          enum_value_overrides_by_type: @enum_value_overrides_by_type,
-          output: @output
-        ).tap do |api|
-          api.as_active_instance { load @path_to_schema.to_s }
+          API.new(
+            @schema_element_names,
+            @index_document_sizes,
+            extension_modules: @extension_modules,
+            derived_type_name_formats: @derived_type_name_formats,
+            type_name_overrides: @type_name_overrides,
+            enum_value_overrides_by_type: @enum_value_overrides_by_type,
+            output: @output
+          ).tap do |api|
+            api.as_active_instance { load @path_to_schema.to_s }
+          end
         end
       end
     end

data/lib/elastic_graph/schema_definition/results.rb

@@ -119,28 +119,28 @@ module ElasticGraph
           query_type.documentation "The query entry point for the entire schema."
           query_type.resolve_fields_with nil
 
-          state.types_by_name.values.select(&:indexed?).sort_by(&:name).each do |type|
-            # @type var indexed_type: Mixins::HasIndices & _Type
-            indexed_type = _ = type
+          state.object_types_by_name.values.select(&:directly_queryable?).sort_by(&:name).each do |type|
+            # @type var root_doc_type: Mixins::HasIndices & _Type
+            root_doc_type = _ = type
 
             query_type.relates_to_many(
-              indexed_type.plural_root_query_field_name,
-              indexed_type.name,
+              root_doc_type.plural_root_query_field_name,
+              root_doc_type.name,
               via: "ignore",
               dir: :in,
-              singular: indexed_type.singular_root_query_field_name
+              singular: root_doc_type.singular_root_query_field_name
             ) do |f|
-              f.documentation "Fetches `#{indexed_type.name}`s based on the provided arguments."
-              f.resolve_with :list_records
+              f.documentation "Fetches `#{root_doc_type.name}`s based on the provided arguments."
+              f.resolve_with :indexed_type_root_fields
               f.hide_relationship_runtime_metadata = true
-              indexed_type.root_query_fields_customizations&.call(f)
+              root_doc_type.root_query_fields_customizations&.call(f)
             end
 
             # Add additional efficiency hints to the aggregation field documentation if we have any such hints.
             # This needs to be outside the `relates_to_many` block because `relates_to_many` adds its own "suffix" to
             # the field documentation, and here we add another one.
-            if (agg_efficiency_hint = aggregation_efficiency_hints_for(indexed_type.derived_indexed_types))
-              agg_name = state.schema_elements.normalize_case("#{indexed_type.singular_root_query_field_name}_aggregations")
+            if (agg_efficiency_hint = aggregation_efficiency_hints_for(root_doc_type.derived_indexed_types))
+              agg_name = state.schema_elements.normalize_case("#{root_doc_type.singular_root_query_field_name}_aggregations")
               agg_field = query_type.graphql_fields_by_name.fetch(agg_name)
               agg_field.documentation "#{agg_field.doc_comment}\n\n#{agg_efficiency_hint}"
             end
@@ -181,7 +181,7 @@ module ElasticGraph
         check_for_circular_dependencies!
 
         index_templates, indices = state.object_types_by_name.values
-          .filter_map(&:index_def)
+          .filter_map(&:own_index_def)
           .sort_by(&:name)
           .partition(&:rollover_config)
 
@@ -209,19 +209,19 @@ module ElasticGraph
 
         scalar_types_by_name = state.scalar_types_by_name.transform_values(&:runtime_metadata)
 
-        enum_generator = state.factory.new_enums_for_indexed_types
+        enum_generator = state.factory.new_enums_for_directly_queryable_types
 
-        indexed_enum_types_by_name = state.object_types_by_name.values
-          .select(&:indexed?)
+        sort_order_enum_types_by_name = state.object_types_by_name.values
+          .select(&:directly_queryable?)
           .filter_map { |type| enum_generator.sort_order_enum_for(_ = type) }
           .to_h { |enum_type| [(_ = enum_type).name, (_ = enum_type).runtime_metadata] }
 
         enum_types_by_name = all_types
           .grep(SchemaElements::EnumType) # : ::Array[SchemaElements::EnumType]
           .to_h { |t| [t.name, t.runtime_metadata] }
-          .merge(indexed_enum_types_by_name)
+          .merge(sort_order_enum_types_by_name)
 
-        index_definitions_by_name = state.object_types_by_name.values.filter_map(&:index_def).to_h do |index|
+        index_definitions_by_name = state.object_types_by_name.values.filter_map(&:own_index_def).to_h do |index|
           [index.name, index.runtime_metadata]
         end
 
@@ -248,7 +248,7 @@ module ElasticGraph
           ::Hash.new { |h, k| h[k] = [] } # : ::Hash[untyped, ::Array[SchemaArtifacts::RuntimeMetadata::UpdateTarget]]
         ) do |object_type, accum|
           fields_with_sources_by_relationship_name =
-            if object_type.index_def.nil?
+            if object_type.own_index_def.nil?
               # only indexed types can have `sourced_from` fields, and resolving `fields_with_sources` on an unindexed union type
               # such as `_Entity` when we are using apollo can lead to exceptions when multiple entity types have the same field name
               # that use different mapping types.
@@ -276,7 +276,7 @@ module ElasticGraph
             resolved_relationship, relationship_error = relationship_resolver.resolve
             relationship_errors << relationship_error if relationship_error
 
-            if object_type.index_def && resolved_relationship && sourced_fields.any?
+            if object_type.own_index_def && resolved_relationship && sourced_fields.any?
               update_target_resolver = Indexing::UpdateTargetResolver.new(
                 object_type: object_type,
                 resolved_relationship: resolved_relationship,
@@ -289,7 +289,7 @@ module ElasticGraph
               sourced_field_errors.concat(errors)
 
               # Validate that has_had_multiple_sources! has been called when sourced_from is used
-              if (index_def = object_type.index_def) && !index_def.has_had_multiple_sources_flag
+              if (index_def = object_type.own_index_def) && !index_def.has_had_multiple_sources_flag
                 sourced_field_errors << "Type `#{object_type.name}` uses `sourced_from` fields but its index `#{index_def.name}` " \
                   "has not been configured with `has_had_multiple_sources!`. To resolve this, add `i.has_had_multiple_sources!` within the " \
                   "`t.index \"#{index_def.name}\"` block. This flag is required because indices with multiple sources can contain " \
@@ -335,8 +335,8 @@ module ElasticGraph
           raise Errors::SchemaError, "`json_schema_version` must be specified in the schema. To resolve, add `schema.json_schema_version 1` in a schema definition block."
         end
 
-        indexed_type_names = state.object_types_by_name.values
-          .select { |type| type.indexed? && !type.abstract? }
+        root_document_type_names = state.object_types_by_name.values
+          .select { |type| type.root_document_type? && !type.abstract? }
           .reject { |type| derived_indexing_type_names.include?(type.name) }
           .map(&:name)
 
@@ -348,7 +348,7 @@ module ElasticGraph
           "$schema" => JSON_META_SCHEMA,
           JSON_SCHEMA_VERSION_KEY => json_schema_version,
           "$defs" => {
-            "ElasticGraphEventEnvelope" => Indexing::EventEnvelope.json_schema(indexed_type_names, json_schema_version)
+            "ElasticGraphEventEnvelope" => Indexing::EventEnvelope.json_schema(root_document_type_names, json_schema_version)
           }.merge(definitions_by_name)
         }
       end
@@ -381,16 +381,14 @@ module ElasticGraph
             end
           end
 
-        unused_resolvers = registered_resolvers.except(*fields_by_resolvers.keys).reject do |name, res|
-          # Ignore our built-in resolvers.
-          res.resolver_ref.fetch("require_path").start_with?("elastic_graph/graphql/resolvers/")
-        end.keys
+        unused_resolvers = registered_resolvers.except(*fields_by_resolvers.keys, *state.built_in_graphql_resolvers.to_a).keys
 
         unless unused_resolvers.empty?
           state.output.puts <<~EOS
             WARNING: #{unused_resolvers.size} GraphQL resolver(s) have been registered but are unused:
               - #{unused_resolvers.sort.join("\n  - ")}
-            These resolvers can be removed.
+            These resolvers can be removed. If you intended for them to be available as built-in/internal
+            resolvers, pass `built_in: true` when registering them.
           EOS
         end
 

data/lib/elastic_graph/schema_definition/schema_artifact_manager.rb

@@ -9,13 +9,14 @@
 require "did_you_mean"
 require "elastic_graph/constants"
 require "elastic_graph/schema_definition/json_schema_pruner"
+require "elastic_graph/support/graphql_gem_loader"
 require "elastic_graph/support/memoizable_data"
 require "fileutils"
-require "graphql"
-require "graphql/c_parser"
 require "tempfile"
 require "yaml"
 
+ElasticGraph::Support::GraphQLGemLoader.load
+
 module ElasticGraph
   module SchemaDefinition
     # Manages schema artifacts. Note: not tested directly. Instead, the `RakeTasks` tests drive this class.

data/lib/elastic_graph/schema_definition/schema_elements/built_in_types.rb

@@ -1425,25 +1425,30 @@ module ElasticGraph
           require(require_path = "elastic_graph/graphql/resolvers/get_record_field_value")
           schema_def_api.register_graphql_resolver :get_record_field_value,
             GraphQL::Resolvers::GetRecordFieldValue,
-            defined_at: require_path
+            defined_at: require_path,
+            built_in: true
 
-          require(require_path = "elastic_graph/graphql/resolvers/list_records")
-          schema_def_api.register_graphql_resolver :list_records,
-            GraphQL::Resolvers::ListRecords,
-            defined_at: require_path
+          require(require_path = "elastic_graph/graphql/resolvers/indexed_type_root_fields_resolver")
+          schema_def_api.register_graphql_resolver :indexed_type_root_fields,
+            GraphQL::Resolvers::IndexedTypeRootFieldsResolver,
+            defined_at: require_path,
+            built_in: true
 
           require(require_path = "elastic_graph/graphql/resolvers/nested_relationships")
           schema_def_api.register_graphql_resolver :nested_relationships,
             GraphQL::Resolvers::NestedRelationships,
-            defined_at: require_path
+            defined_at: require_path,
+            built_in: true
 
           require(require_path = "elastic_graph/graphql/resolvers/object")
           schema_def_api.register_graphql_resolver :object_with_lookahead,
             GraphQL::Resolvers::Object::WithLookahead,
-            defined_at: require_path
+            defined_at: require_path,
+            built_in: true
           schema_def_api.register_graphql_resolver :object_without_lookahead,
             GraphQL::Resolvers::Object::WithoutLookahead,
-            defined_at: require_path
+            defined_at: require_path,
+            built_in: true
         end
 
         def define_date_grouping_arguments(grouping_field, omit_timezone: false)

data/lib/elastic_graph/schema_definition/schema_elements/enum_type.rb

@@ -161,11 +161,6 @@ module ElasticGraph
           Indexing::FieldType::Enum.new(values_by_name.keys)
         end
 
-        # @return [false] enum types are never directly indexed
-        def indexed?
-          false
-        end
-
         # @return [EnumType] converts the enum type to its input form for when different naming is used for input vs output enums.
         def as_input
           input_name = type_ref

data/lib/elastic_graph/schema_definition/schema_elements/{enums_for_indexed_types.rb → enums_for_directly_queryable_types.rb}

@@ -12,19 +12,19 @@ require "elastic_graph/schema_artifacts/runtime_metadata/sort_field"
 module ElasticGraph
   module SchemaDefinition
     module SchemaElements
-      # Responsible for generating enum types based on specific indexed types.
+      # Responsible for generating enum types based on specific directly queryable types.
       #
       # @private
-      class EnumsForIndexedTypes
+      class EnumsForDirectlyQueryableTypes
         def initialize(schema_def_state)
           @schema_def_state = schema_def_state
         end
 
-        # Generates a `SortOrder` enum type for the given indexed type.
-        def sort_order_enum_for(indexed_type)
-          return nil unless indexed_type.indexed?
+        # Generates a `SortOrder` enum type for the given directly queryable type.
+        def sort_order_enum_for(type)
+          return nil unless type.directly_queryable?
 
-          build_enum(indexed_type, :sort_order, :sortable?, "sorted") do |enum_type, field_path|
+          build_enum(type, :sort_order, :sortable?, "sorted") do |enum_type, field_path|
             value_name_parts = field_path.map(&:name)
             index_field = field_path.map(&:name_in_index).join(".")
 
@@ -45,12 +45,12 @@ module ElasticGraph
 
         private
 
-        def build_enum(indexed_type, category, field_predicate, past_tense_verb, &block)
-          derived_type_ref = indexed_type.type_ref.as_static_derived_type(category)
+        def build_enum(type, category, field_predicate, past_tense_verb, &block)
+          derived_type_ref = type.type_ref.as_static_derived_type(category)
 
           enum = @schema_def_state.factory.new_enum_type(derived_type_ref.name) do |enum_type|
-            enum_type.documentation "Enumerates the ways `#{indexed_type.name}`s can be #{past_tense_verb}."
-            define_enum_values_for_type(enum_type, indexed_type, field_predicate, &block)
+            enum_type.documentation "Enumerates the ways `#{type.name}`s can be #{past_tense_verb}."
+            define_enum_values_for_type(enum_type, type, field_predicate, &block)
           end.as_input
 
           enum unless enum.values_by_name.empty?

data/lib/elastic_graph/schema_definition/schema_elements/field.rb

@@ -73,6 +73,8 @@ module ElasticGraph
       #   @private
       # @!attribute [rw] highlightable
       #   @private
+      # @!attribute [rw] returnable
+      #   @private
       # @!attribute [rw] source
       #   @private
       # @!attribute [rw] runtime_field_script
@@ -91,7 +93,7 @@ module ElasticGraph
         :name, :original_type, :parent_type, :original_type_for_derived_types, :schema_def_state, :accuracy_confidence,
         :filter_customizations, :grouped_by_customizations, :highlights_customizations, :sub_aggregations_customizations,
         :aggregated_values_customizations, :sort_order_enum_value_customizations, :args,
-        :sortable, :filterable, :aggregatable, :groupable, :highlightable,
+        :sortable, :filterable, :aggregatable, :groupable, :highlightable, :returnable,
         :graphql_only, :source, :runtime_field_script, :relationship, :singular_name,
         :computation_detail, :non_nullable_in_json_schema, :as_input,
         :name_in_index, :resolver
@@ -106,7 +108,7 @@ module ElasticGraph
           name:, type:, parent_type:, schema_def_state:,
           accuracy_confidence: :high, name_in_index: name,
           type_for_derived_types: nil, graphql_only: nil, singular: nil,
-          sortable: nil, filterable: nil, aggregatable: nil, groupable: nil, highlightable: nil,
+          sortable: nil, filterable: nil, aggregatable: nil, groupable: nil, highlightable: nil, returnable: nil,
           as_input: false, resolver: nil
         )
           type_ref = schema_def_state.type_ref(type)
@@ -129,6 +131,7 @@ module ElasticGraph
             aggregatable: aggregatable,
             groupable: groupable,
             highlightable: highlightable,
+            returnable: returnable,
             graphql_only: graphql_only,
             source: nil,
             runtime_field_script: nil,
@@ -677,10 +680,10 @@ module ElasticGraph
           # If the groupability of the field was specified explicitly when the field was defined, use the specified value.
           return groupable unless groupable.nil?
 
-          # We don't want the `id` field of an indexed type to be available to group by, because it's the unique primary key
+          # We don't want the `id` field of a root document type to be available to group by, because it's the unique primary key
           # and the groupings would each contain one document. It's simpler and more efficient to just query the raw documents
           # instead.
-          return false if parent_type.indexed? && name == "id"
+          return false if parent_type.root_document_type? && name == "id"
 
           return false if relationship || type.fully_unwrapped.as_object_type&.does_not_support?(&:groupable?)
 
@@ -738,11 +741,22 @@ module ElasticGraph
         def highlightable?
           return highlightable unless highlightable.nil?
           return false if relationship
+          return false unless returnable?
           return true if HIGHLIGHTABLE_MAPPING_TYPES.include?(mapping_type)
 
           type_for_derived_types.fully_unwrapped.as_object_type&.supports?(&:highlightable?)
         end
 
+        # Indicates if this field is returnable in GraphQL query responses. When `false`, the field will
+        # still be available for filtering, sorting, grouping, and aggregation, but will not appear in the
+        # GraphQL output type and its data will be excluded from `_source` in the datastore for storage savings.
+        #
+        # @return [Boolean] true if this field's data can be returned (default: true)
+        def returnable?
+          return true if returnable.nil?
+          returnable
+        end
+
         # Defines an argument on the field.
         #
         # @note ElasticGraph takes care of defining arguments for all the query features it supports, so there is generally no need to use
@@ -892,7 +906,10 @@ module ElasticGraph
             parent_type: parent_type,
             name_in_index: name_in_index,
             type_for_derived_types: nil,
-            resolver: nil
+            resolver: nil,
+            # Filter fields should always appear in their parent input type's SDL regardless
+            # of the source field's returnability.
+            returnable: true
           )
 
           schema_def_state.factory.new_field(**params).tap do |f|

data/lib/elastic_graph/schema_definition/schema_elements/object_type.rb

@@ -30,7 +30,7 @@ module ElasticGraph
         include Mixins::SupportsFilteringAndAggregation
 
         # `include HasIndices` provides the following methods:
-        # @dynamic runtime_metadata, derived_indexed_types, indices, indexed?, abstract?
+        # @dynamic runtime_metadata, derived_indexed_types, indices, root_document_type?, abstract?, directly_queryable?
         include Mixins::HasIndices
 
         # `include ImplementsInterfaces` provides the following methods:
@@ -38,6 +38,16 @@ module ElasticGraph
         include Mixins::ImplementsInterfaces
         include Mixins::HasReadableToSAndInspect.new { |t| t.name }
 
+        # @return [Hash<String, Field>] fields that will be indexed, including __typename for mixed-type indices (types
+        # that inherit an index from an abstract supertype)
+        # @private
+        def indexing_fields_by_name_in_index
+          return super if has_own_index_def?
+          return super unless root_document_type?
+
+          super.merge("__typename" => schema_def_state.factory.new_field(name: "__typename", type: "String", parent_type: self))
+        end
+
         # @private
         def initialize(schema_def_state, name)
           field_factory = schema_def_state.factory.method(:new_field)

data/lib/elastic_graph/schema_definition/schema_elements/scalar_type.rb

@@ -236,11 +236,6 @@ module ElasticGraph
           end
         end
 
-        # @private
-        def indexed?
-          false
-        end
-
         private
 
         EQUAL_TO_ANY_OF_DOC = <<~EOS

data/lib/elastic_graph/schema_definition/schema_elements/sub_aggregation_path.rb

@@ -28,7 +28,7 @@ module ElasticGraph
 
         # Determines the set of sub aggregation paths for the given type.
         def self.paths_for(type, schema_def_state:)
-          root_paths = type.indexed? ? [SubAggregationPath.new([type.name], [])] : [] # : ::Array[SubAggregationPath]
+          root_paths = type.root_document_type? ? [SubAggregationPath.new([type.name], [])] : [] # : ::Array[SubAggregationPath]
 
           non_relation_field_refs = schema_def_state
             .user_defined_field_references_by_type_name.fetch(type.name) { [] }

data/lib/elastic_graph/schema_definition/schema_elements/type_with_subfields.rb

@@ -137,6 +137,9 @@ module ElasticGraph
         #   ElasticGraph will infer field sortability based on the field's GraphQL type and mapping type.
         # @option options [Boolean] highlightable force-enables or disables the ability to request search highlights for this field. When
         #   not provided, ElasticGraph will infer field highlightable based on the field's mapping type.
+        # @option options [Boolean] returnable when set to `false`, the field will not appear in the GraphQL output type and its data
+        #   will be excluded from `_source` in the datastore for storage savings. The field will still be available for filtering,
+        #   sorting, grouping, and aggregation. Defaults to `true`.
         # @yield [Field] the field for further customization
         # @return [void]
         #
@@ -470,11 +473,6 @@ module ElasticGraph
           schema_def_state.type_ref("NonNumeric").as_aggregated_values
         end
 
-        # @private
-        def indexed?
-          false
-        end
-
         # @private
         def to_indexing_field_type
           Indexing::FieldType::Object.new(
@@ -536,6 +534,7 @@ module ElasticGraph
 
         def fields_sdl(&arg_selector)
           graphql_fields_by_name.values
+            .select(&:returnable?)
             .map { |f| f.to_sdl(&arg_selector) }
             .flat_map { |sdl| sdl.split("\n") }
             .join("\n  ")

data/lib/elastic_graph/schema_definition/schema_elements/union_type.rb

@@ -94,6 +94,9 @@ module ElasticGraph
           end
 
           subtype_refs << type_ref
+
+          # Register reverse lookup so we can efficiently find which unions contain this type
+          schema_def_state.union_types_by_member_ref[type_ref] << self
         end
 
         # Defines multiple subtypes of this union type.
@@ -128,6 +131,15 @@ module ElasticGraph
           "#{formatted_documentation}union #{name} #{directives_sdl(suffix_with: " ")}= #{subtype_refs.map(&:name).to_a.join(" | ")}"
         end
 
+        # Union types cannot themselves be members of other unions or implement interfaces,
+        # so they have no supertypes.
+        #
+        # @return [Set] empty set
+        # @private
+        def recursively_resolve_supertypes
+          Set[]
+        end
+
         # @private
         def verify_graphql_correctness!
           # Nothing to verify. `verify_graphql_correctness!` will be called on each subtype automatically.

data/lib/elastic_graph/schema_definition/state.rb

@@ -32,6 +32,7 @@ module ElasticGraph
       :scalar_types_by_name,
       :enum_types_by_name,
       :implementations_by_interface_ref,
+      :union_types_by_member_ref,
       :sdl_parts,
       :paginated_collection_element_types,
       :user_defined_fields,
@@ -43,7 +44,7 @@ module ElasticGraph
       :json_schema_version_setter_location,
       :graphql_extension_modules,
       :graphql_resolvers_by_name,
-      :resolvers_by_name,
+      :built_in_graphql_resolvers,
       :initially_registered_built_in_types,
       :built_in_types_customization_blocks,
       :user_definition_complete,
@@ -54,7 +55,8 @@ module ElasticGraph
       :type_namer,
       :enum_value_namer,
       :allow_omitted_json_schema_fields,
-      :allow_extra_json_schema_fields
+      :allow_extra_json_schema_fields,
+      :indexed_types_by_index_name
     )
       include Mixins::HasReadableToSAndInspect.new
 
@@ -79,6 +81,7 @@ module ElasticGraph
           scalar_types_by_name: {},
           enum_types_by_name: {},
           implementations_by_interface_ref: ::Hash.new { |h, k| h[k] = ::Set.new },
+          union_types_by_member_ref: ::Hash.new { |h, k| h[k] = ::Set.new },
           sdl_parts: [],
           paginated_collection_element_types: ::Set.new,
           user_defined_fields: ::Set.new,
@@ -90,6 +93,7 @@ module ElasticGraph
           json_schema_version: nil,
           graphql_extension_modules: [],
           graphql_resolvers_by_name: {},
+          built_in_graphql_resolvers: ::Set.new,
           initially_registered_built_in_types: ::Set.new,
           built_in_types_customization_blocks: [],
           user_definition_complete: false,
@@ -103,7 +107,8 @@ module ElasticGraph
           enum_value_namer: SchemaElements::EnumValueNamer.new(enum_value_overrides_by_type),
           output: output,
           allow_omitted_json_schema_fields: false,
-          allow_extra_json_schema_fields: true
+          allow_extra_json_schema_fields: true,
+          indexed_types_by_index_name: {}
         )
       end
 
@@ -132,6 +137,13 @@ module ElasticGraph
         register_type(type)
       end
 
+      def register_index(name, type)
+        if (existing_type = indexed_types_by_index_name[name])
+          raise Errors::SchemaError, "Duplicate index name `#{name}` defined on `#{type.name}` and `#{existing_type.name}`. Each index can only be defined once."
+        end
+        indexed_types_by_index_name[name] = type
+      end
+
       def register_renamed_type(type_name, from:, defined_at:, defined_via:)
         renamed_types_by_old_name[from] = factory.new_deprecated_element(
           type_name,
@@ -185,8 +197,8 @@ module ElasticGraph
         @factory ||= Factory.new(self)
       end
 
-      def enums_for_indexed_types
-        @enums_for_indexed_types ||= factory.new_enums_for_indexed_types
+      def enums_for_directly_queryable_types
+        @enums_for_directly_queryable_types ||= factory.new_enums_for_directly_queryable_types
       end
 
       def sub_aggregation_paths_for(type)