elasticgraph-graphql 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8acfd27b78b920f78cdd6f27781890bc49b77f430f45d785e5f1b8fa66f74dae
-  data.tar.gz: ed33c16391844f8b3321ec5849dba8a7acbe502ace6286aaabc401122d085aee
+  metadata.gz: aff2847d08949b4bdcd6b6d5ad8d4bdd093998f5e0117545b061336c68c79b2c
+  data.tar.gz: 26bad3e27afa0239ac27540a2a1783b51ed6790dfe60db1b6ca8f750dc0f45bf
 SHA512:
-  metadata.gz: cad2e9df85cc80e064599f15d1492496b24a8007ddbdf633ae3862ea55f81725e9fae5d266b3e435ee49787c97558955465ad71305ea57e14719031499812ff1
-  data.tar.gz: 9c3e3ea42f82d421c5319c373f60f23666bee9237ed7df0e84ea2a51f0d7228af49bbc8e3cce9856eaac532b5ea0b0110e7afb9204abd9e737e055743425bb9e
+  metadata.gz: b2e1e76a48dea32a3b3f7e0fd7b8b4f71c94f4a9a0595f9c4890c126d1de05666334095715f0fc680b238f465068918af06844a4bd7f18f0912abbba3406b51f
+  data.tar.gz: a66d894a2098b9109eeeb71faf42290fc349a90af3116b3a1baa7f2fdedaf64baa6c1e4572179b7ea6c4bfb77f2c13b5c1c71f660732f4b3f9ecc714d30fea33

data/README.md

@@ -23,9 +23,6 @@ graph LR;
     graphql["graphql"];
     elasticgraph-graphql --> graphql;
     class graphql externalGemStyle;
-    graphql-c_parser["graphql-c_parser"];
-    elasticgraph-graphql --> graphql-c_parser;
-    class graphql-c_parser externalGemStyle;
     elasticgraph-apollo["elasticgraph-apollo"];
     elasticgraph-apollo --> elasticgraph-graphql;
     class elasticgraph-apollo otherEgGemStyle;
@@ -52,7 +49,6 @@ graph LR;
     class elasticgraph-schema_definition otherEgGemStyle;
     click base64 href "https://rubygems.org/gems/base64" "Open on RubyGems.org" _blank;
     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;
 ```
 
 ## Usage

data/lib/elastic_graph/graphql/client.rb

@@ -13,12 +13,13 @@ module ElasticGraph
     # meant to be a friendly/human readable string (such as a service name)
     # where as `source_description` is meant to be an opaque string describing
     # where `name` came from.
-    class Client < Data.define(:source_description, :name)
+    class Client < Data.define(:source_description, :name, :extra_opaque_id_parts)
       # `Data.define` provides the following methods:
-      # @dynamic initialize, name, source_description, with
+      # @dynamic name, source_description, extra_opaque_id_parts, with
 
-      ANONYMOUS = new("(anonymous)", "(anonymous)")
-      ELASTICGRAPH_INTERNAL = new("(ElasticGraphInternal)", "(ElasticGraphInternal)")
+      def initialize(source_description:, name:, extra_opaque_id_parts: [])
+        super
+      end
 
       def description
         if source_description == name
@@ -38,6 +39,9 @@ module ElasticGraph
           Client::ANONYMOUS
         end
       end
+
+      ANONYMOUS = new("(anonymous)", "(anonymous)")
+      ELASTICGRAPH_INTERNAL = new("(ElasticGraphInternal)", "(ElasticGraphInternal)")
     end
   end
 end

data/lib/elastic_graph/graphql/datastore_search_router.rb

@@ -10,6 +10,7 @@ require "elastic_graph/constants"
 require "elastic_graph/errors"
 require "elastic_graph/graphql/datastore_response/search_response"
 require "elastic_graph/graphql/query_details_tracker"
+require "elastic_graph/support/opaque_id"
 require "elastic_graph/support/threading"
 
 module ElasticGraph
@@ -32,7 +33,7 @@ module ElasticGraph
 
       # Sends the datastore a multi-search request based on the given queries.
       # Returns a hash of responses keyed by the query.
-      def msearch(queries, query_tracker: QueryDetailsTracker.empty)
+      def msearch(queries, query_tracker: QueryDetailsTracker.empty, opaque_id_parts: ["elasticgraph-graphql"])
         DatastoreQuery.perform(queries) do |header_body_tuples_by_query|
           # Here we set a client-side timeout, which causes the client to give up and close the connection.
           # According to [1]--"We have a new way to cancel search requests efficiently from the client
@@ -64,6 +65,9 @@ module ElasticGraph
           # even though Faraday (the underlying HTTP client) does. To work around this, we pass our desired
           # timeout in a specific header that the `SupportTimeouts` Faraday middleware will use.
           headers = {TIMEOUT_MS_HEADER => msearch_request_timeout_from(queries)&.to_s}.compact
+          if (opaque_id = Support::OpaqueID.build_header(opaque_id_parts))
+            headers[OPAQUE_ID_HEADER] = opaque_id
+          end
 
           queries_and_header_body_tuples_by_datastore_client = header_body_tuples_by_query.group_by do |(query, header_body_tuples)|
             @datastore_clients_by_name.fetch(query.cluster_name)

data/lib/elastic_graph/graphql/query_adapter/abstract_type_filter.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
+
+module ElasticGraph
+  class GraphQL
+    class QueryAdapter
+      # Query adapter that injects a `__typename` filter when querying an abstract type (interface
+      # or union) that shares an index with types that fall outside the set of its subtypes. Without
+      # this filter, documents belonging to those other types would incorrectly appear in results.
+      #
+      # For example, given this hierarchy:
+      #
+      #   DistributionChannel (abstract interface, index: distribution_channels)
+      #   ├── Wholesale            (abstract interface, distribution_channels index)
+      #   │   ├── DirectWholesaler (concrete, distribution_channels index)
+      #   │   └── BrokerWholesaler (concrete, distribution_channels index)
+      #   └── Retail               (abstract interface, distribution_channels index)
+      #       └── Store            (abstract interface, distribution_channels index)
+      #           ├── OnlineStore  (concrete, distribution_channels index)
+      #           └── PhysicalStore (concrete, physical_stores index — dedicated)
+      #
+      # A query for `retailers` (i.e. the `Retail` interface) searches both `distribution_channels`
+      # and `physical_stores`. Without a `__typename` filter, `DirectWholesaler` and
+      # `BrokerWholesaler` documents from `distribution_channels` would appear in results.
+      # So we inject:
+      #
+      #   __typename: { equal_to_any_of: ["OnlineStore", "PhysicalStore"] }
+      #
+      # `PhysicalStore` has a dedicated index with `__typename` stored as a `constant_keyword`,
+      # so it matches the `equal_to_any_of` filter just like documents in the shared index.
+      class AbstractTypeFilter
+        def initialize(schema_element_names)
+          @equal_to_any_of = schema_element_names.equal_to_any_of
+        end
+
+        def call(field:, query:, args:, lookahead:, context:)
+          type = field.type.unwrap_fully
+
+          # For derived types (e.g. indexed aggregations), resolve the underlying document type so we can
+          # apply the same __typename scoping as we do for document queries.
+          doc_type = type.source_type || type
+
+          return query unless doc_type.shares_index_with_non_subtypes?
+
+          subtypes = doc_type.subtypes # Note: subtypes returns all concrete subtypes at any depth
+          typename_values = subtypes.map(&:name)
+          query.merge_with(internal_filters: [{
+            "__typename" => {@equal_to_any_of => typename_values}
+          }])
+        end
+      end
+    end
+  end
+end

data/lib/elastic_graph/graphql/query_adapter/requested_fields.rb

@@ -55,7 +55,7 @@ module ElasticGraph
                 .selection(@schema.element_names.highlights)
 
               {
-                individual_docs_needed: pagination_fields_need_individual_docs?(lookahead),
+                individual_docs_needed: pagination_fields_need_individual_docs?(lookahead) || relay_connection_node_from(lookahead).selected?,
                 requested_fields: requested_fields_under(relay_connection_node_from(lookahead), index_field_paths),
                 request_all_highlights: requesting_all_highlights?(lookahead),
                 requested_highlights: requested_fields_under(highlights, index_field_paths)
@@ -86,7 +86,10 @@ module ElasticGraph
             requested_fields_for(child, index_field_paths, path_prefix: path_prefix)
           end
 
-          fields << "#{path_prefix}__typename" if field_for(node.field)&.type&.abstract?
+          # For abstract types (unions/interfaces), we need __typename to resolve the concrete type.
+          # We must fully unwrap the type to check the innermost type, since the field type could be
+          # wrapped in non-null or list wrappers (e.g., `[NamedInventor!]!` on a `nodes` relay connection field).
+          fields << "#{path_prefix}__typename" if field_for(node.field)&.type&.unwrap_fully&.abstract?
           fields
         end
 

data/lib/elastic_graph/graphql/query_executor.rb

@@ -59,7 +59,8 @@ module ElasticGraph
           client: client,
           context: context.merge({
             monotonic_clock_deadline: timeout_in_ms&.+(start_time_in_ms),
-            elastic_graph_query_tracker: query_tracker
+            elastic_graph_query_tracker: query_tracker,
+            elastic_graph_client: client
           }.compact)
         )
 
@@ -89,7 +90,7 @@ module ElasticGraph
           @logger.info({
             "message_type" => "ElasticGraphQueryExecutorQueryDuration",
             "client" => client.name,
-            "query_fingerprint" => fingerprint_for(query),
+            "query_fingerprint" => query.fingerprint,
             "query_name" => query.selected_operation_name,
             "duration_ms" => duration,
             # How long the datastore queries took according to what the datastore itself reported.
@@ -142,7 +143,7 @@ module ElasticGraph
       def execute_query(query, client:)
         # Log the query before starting to execute it, in case there's a lambda timeout, in which case
         # we won't get any other logged messages for the query.
-        @logger.info "Starting to execute query #{fingerprint_for(query)} for client #{client.description}."
+        @logger.info "Starting to execute query #{query.fingerprint} for client #{client.description}."
 
         query.result
       rescue => ex
@@ -163,11 +164,7 @@ module ElasticGraph
       # the fingerprint to make sure that we at least have some identification information
       # about the query.
       def full_description_of(query)
-        "#{fingerprint_for(query)} #{query.sanitized_query_string}"
-      end
-
-      def fingerprint_for(query)
-        query.query_string ? query.fingerprint : "(no query string)"
+        "#{query.fingerprint} #{query.sanitized_query_string}"
       end
 
       def slo_result_for(query, duration)

data/lib/elastic_graph/graphql/resolvers/graphql_adapter_builder.rb

@@ -110,8 +110,9 @@ module ElasticGraph
         # In order to support unions and interfaces, we must implement `resolve_type`.
         def resolve_type(supertype, object, context)
           schema = context.fetch(:elastic_graph_schema)
-          # If `__typename` is available, use that to resolve. It should be available on any embedded abstract types...
-          # (See `Inventor` in `config/schema.graphql` for an example of this kind of type union.)
+          # If `__typename` is available, use that to resolve. It will be present on embedded abstract
+          # types, and also on root documents indexed in a shared interface/union index.
+          # (See `Inventor` in `config/schema/widgets.rb` for an example of an embedded abstract type.)
           if (typename = object["__typename"])
             schema
               .graphql_schema
@@ -121,7 +122,9 @@ module ElasticGraph
             # ...otherwise infer the type based on what index the object came from. This is the case
             # with unions/interfaces of individually indexed types.
             # (See `Part` in `config/schema/widgets.rb` for an example of this kind of type union.)
-            schema.document_type_stored_in(object.index_definition_name).graphql_type
+            # This branch is only reached for individually-indexed types (no `__typename`
+            # in the document), so the set always contains exactly one type.
+            schema.document_types_stored_in(object.index_definition_name).first.graphql_type
           end
         end
       end

data/lib/elastic_graph/graphql/resolvers/{list_records.rb → indexed_type_root_fields_resolver.rb}

@@ -12,8 +12,8 @@ require "elastic_graph/graphql/resolvers/relay_connection"
 module ElasticGraph
   class GraphQL
     module Resolvers
-      # Responsible for fetching a a list of records of a particular type
-      class ListRecords
+      # Responsible for resolving the list and aggregation root fields generated for each indexed type.
+      class IndexedTypeRootFieldsResolver
         def initialize(elasticgraph_graphql:, config:)
           # Nothing to initialize, but needs to be defined to satisfy the resolver interface.
         end

data/lib/elastic_graph/graphql/resolvers/query_source.rb

@@ -20,28 +20,48 @@ module ElasticGraph
       # Note: `NestedRelationshipsSource` implements further optimizations on top of this, and should
       # be used rather than this class when applicable.
       class QuerySource < ::GraphQL::Dataloader::Source
-        def initialize(datastore_router, query_tracker)
+        def initialize(datastore_router, query_tracker, opaque_id_parts = [])
           @datastore_router = datastore_router
           @query_tracker = query_tracker
+          @opaque_id_parts = opaque_id_parts
         end
 
         def fetch(queries)
-          responses_by_query = @datastore_router.msearch(queries, query_tracker: @query_tracker)
+          responses_by_query = @datastore_router.msearch(
+            queries,
+            query_tracker: @query_tracker,
+            opaque_id_parts: @opaque_id_parts
+          )
           queries.map { |q| responses_by_query.fetch(q) }
         end
 
         def self.execute_many(queries, for_context:)
           datastore_router = for_context.fetch(:datastore_search_router)
           query_tracker = for_context.fetch(:elastic_graph_query_tracker)
+          opaque_id_parts = datastore_opaque_id_parts_for(for_context)
           dataloader = for_context.dataloader
 
-          responses = dataloader.with(self, datastore_router, query_tracker).load_all(queries)
+          responses = dataloader.with(self, datastore_router, query_tracker, opaque_id_parts).load_all(queries)
           queries.zip(responses).to_h
         end
 
         def self.execute_one(query, for_context:)
           execute_many([query], for_context: for_context).fetch(query)
         end
+
+        # `QueryExecutor` adds `:elastic_graph_client` to the GraphQL context before
+        # resolver execution begins, so resolver-side datastore queries can reuse the
+        # same client identity in their datastore `X-Opaque-Id` headers.
+        private_class_method def self.datastore_opaque_id_parts_for(for_context)
+          client = for_context.fetch(:elastic_graph_client)
+          graphql_query = for_context.query
+          [
+            "elasticgraph-graphql",
+            "client=#{client.name}",
+            *client.extra_opaque_id_parts,
+            "query=#{graphql_query.fingerprint}"
+          ]
+        end
       end
     end
   end

data/lib/elastic_graph/graphql/resolvers/relay_connection/search_response_adapter_builder.rb

@@ -47,7 +47,16 @@ module ElasticGraph
 
           def all_highlights
             @all_highlights ||= begin
-              document_type = schema.document_type_stored_in(node.index_definition_name)
+              document_type =
+                if (typename = node["__typename"])
+                  # When multiple types share an index, documents carry a `__typename` field
+                  # that identifies the concrete type; use it to resolve the concrete type directly.
+                  schema.type_named(typename)
+                else
+                  # Index inheritance always injects `__typename` into any shared index mapping,
+                  # so a missing `__typename` means no sharing — the set contains exactly one type.
+                  schema.document_types_stored_in(node.index_definition_name).first # : Schema::Type
+                end
 
               node.highlights.filter_map do |path_string, snippets|
                 if (path = path_from(path_string, document_type))

data/lib/elastic_graph/graphql/schema/type.rb

@@ -61,12 +61,12 @@ module ElasticGraph
         # List of index definitions that should be searched for this type.
         def search_index_definitions
           @search_index_definitions ||=
-            if indexed_aggregation?
-              # For an indexed aggregation, we just delegate to its source type. This works better than
-              # dumping index definitions in the runtime metadata of the indexed aggregation type itself
-              # because of abstract (interface/union) types. The source document type handles that (since
-              # there is a supertype/subtype relationship on the document types) but that relationship
-              # does not exist on the indexed aggregation.
+            if (st = source_type)
+              # When a type has a source type (a prime example being indexed aggregations), we delegate
+              # to the source type. This works better than dumping index definitions in the runtime metadata
+              # of the derived type itself because of abstract (interface/union) types. The source document
+              # type handles that (since there is a supertype/subtype relationship on the document types)
+              # but that relationship does not exist on derived types.
               #
               # For example, assume we have these indexed document types:
               # - type Person {}
@@ -76,9 +76,15 @@ module ElasticGraph
               # 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
+              st.search_index_definitions
+            elsif abstract?
+              # For abstract types, derive search indexes purely from concrete subtypes. This correctly
+              # handles cases where subtypes override the abstract type's declared index with a dedicated
+              # one — only indexes that actually contain documents for this type are searched.
+              # Note: subtypes returns all concrete subtypes at any depth, so no explicit recursion is needed.
+              subtypes.flat_map(&:search_index_definitions).to_set
             else
-              @index_definitions.union(subtypes.flat_map(&:search_index_definitions))
+              @index_definitions
             end
         end
 
@@ -117,13 +123,35 @@ module ElasticGraph
           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
             .graphql_schema
             .possible_types(graphql_type, visibility_profile: :boot)
-            .map { |t| @schema.type_from(t) } - [self]
+            .map { |t| @schema.type_from(t) }
+            .reject { |t| t == self }
+            .to_set
+        end
+
+        # For derived types (e.g. indexed aggregations), returns the underlying source document type.
+        # Returns `nil` for non-derived types.
+        def source_type
+          return @source_type if defined?(@source_type)
+          @source_type = @object_runtime_metadata&.source_type&.then { |st| @schema.type_named(st) }
+        end
+
+        # Returns true if any of this type's search indexes contain any concrete document types
+        # that are not subtypes of this type. Used to determine whether a `__typename` filter is
+        # needed when querying an abstract type.
+        def shares_index_with_non_subtypes?
+          return @shares_index_with_non_subtypes if defined?(@shares_index_with_non_subtypes)
+          @shares_index_with_non_subtypes =
+            search_index_definitions.any? do |index_def|
+              @schema.document_types_stored_in(index_def.name).any? do |t|
+                t != self && !subtypes.include?(t) && !t.abstract?
+              end
+            end
         end
 
         def field_named(field_name)

data/lib/elastic_graph/graphql/schema.rb

@@ -120,7 +120,12 @@ module ElasticGraph
         raise Errors::NotFoundError, msg
       end
 
-      def document_type_stored_in(index_definition_name)
+      # Returns all indexed document types stored in the named index definition.
+      # The returned set includes both abstract and concrete types. Multiple types may be returned
+      # when abstract types share an index with their concrete subtypes via index inheritance.
+      # @raise [Errors::NotFoundError] if the index definition name is not recognized
+      # @raise [ArgumentError] if given the name of a rollover index instead of the parent index definition name
+      def document_types_stored_in(index_definition_name)
         indexed_document_types_by_index_definition_name.fetch(index_definition_name) do
           if index_definition_name.include?(ROLLOVER_INDEX_INFIX_MARKER)
             raise ArgumentError, "`#{index_definition_name}` is the name of a rollover index; pass the name of the parent index definition instead."
@@ -190,16 +195,14 @@ module ElasticGraph
         end
       end
 
+      # Intentionally private: public callers should use `document_types_stored_in` instead.
       def indexed_document_types_by_index_definition_name
-        @indexed_document_types_by_index_definition_name ||= indexed_document_types.each_with_object({}) do |type, hash|
-          type.index_definitions.each do |index_def|
-            if hash.key?(index_def.name)
-              raise Errors::SchemaError, "DatastoreCore::IndexDefinition #{index_def.name} is used multiple times: #{type} vs #{hash[index_def.name]}"
+        @indexed_document_types_by_index_definition_name ||=
+          indexed_document_types.each_with_object(::Hash.new { |h, k| h[k] = ::Set.new }) do |type, hash|
+            type.index_definitions.each do |index_def|
+              hash[index_def.name] << type
             end
-
-            hash[index_def.name] = type
-          end
-        end.freeze
+          end.freeze
       end
 
       def log_hidden_types

data/lib/elastic_graph/graphql.rb

@@ -10,6 +10,7 @@ require "elastic_graph/datastore_core"
 require "elastic_graph/graphql/config"
 require "elastic_graph/constants"
 require "elastic_graph/support/from_yaml_file"
+require "elastic_graph/support/graphql_gem_loader"
 
 module ElasticGraph
   # The main entry point for ElasticGraph GraphQL handling. Instantiate this to get access to the
@@ -132,13 +133,7 @@ module ElasticGraph
     # @private
     def graphql_gem_plugins
       @graphql_gem_plugins ||= begin
-        require "graphql"
-        # As per https://graphql-ruby.org/language_tools/c_parser.html, loading the
-        # C parser causes the faster parser to be assigned as the `::GraphQL.default_parser`,
-        # providing greater efficiency.
-        #
-        # We load it here since this is where we load the GraphQL gem.
-        require "graphql/c_parser"
+        Support::GraphQLGemLoader.load
 
         {
           # We depend on this to avoid N+1 calls to the datastore.
@@ -197,6 +192,7 @@ module ElasticGraph
     def datastore_query_adapters
       @datastore_query_adapters ||= begin
         require "elastic_graph/graphql/aggregation/query_adapter"
+        require "elastic_graph/graphql/query_adapter/abstract_type_filter"
         require "elastic_graph/graphql/query_adapter/filters"
         require "elastic_graph/graphql/query_adapter/pagination"
         require "elastic_graph/graphql/query_adapter/sort"
@@ -205,6 +201,7 @@ module ElasticGraph
         schema_element_names = runtime_metadata.schema_element_names
 
         [
+          GraphQL::QueryAdapter::AbstractTypeFilter.new(schema_element_names),
           GraphQL::QueryAdapter::Pagination.new(schema_element_names: schema_element_names),
           GraphQL::QueryAdapter::Filters.new(
             schema_element_names: schema_element_names,
@@ -268,9 +265,7 @@ module ElasticGraph
     # at boot time instead of deferring dependency loading until we handle the first query. In other environments (such as tests),
     # it's nice to load dependencies when needed.
     def load_dependencies_eagerly
-      require "graphql"
-      require "graphql/c_parser"
-
+      Support::GraphQLGemLoader.load
       ::GraphQL.eager_load!
 
       # run a simple GraphQL query to force load any dependencies needed to handle GraphQL queries

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elasticgraph-graphql
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Myron Marston
@@ -31,132 +31,112 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: elasticgraph-schema_artifacts
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: graphql
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.5.18
+        version: 2.6.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.5.18
-- !ruby/object:Gem::Dependency
-  name: graphql-c_parser
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.3
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.3
+        version: 2.6.2
 - !ruby/object:Gem::Dependency
   name: elasticgraph-admin
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: elasticgraph-elasticsearch
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: elasticgraph-opensearch
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: elasticgraph-indexer
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: elasticgraph-schema_definition
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.2.0
 email:
 - myron@squareup.com
 executables: []
@@ -205,6 +185,7 @@ files:
 - lib/elastic_graph/graphql/filtering/filter_value_set_extractor.rb
 - lib/elastic_graph/graphql/filtering/range_query.rb
 - lib/elastic_graph/graphql/http_endpoint.rb
+- lib/elastic_graph/graphql/query_adapter/abstract_type_filter.rb
 - lib/elastic_graph/graphql/query_adapter/filters.rb
 - lib/elastic_graph/graphql/query_adapter/pagination.rb
 - lib/elastic_graph/graphql/query_adapter/requested_fields.rb
@@ -213,7 +194,7 @@ files:
 - lib/elastic_graph/graphql/query_executor.rb
 - lib/elastic_graph/graphql/resolvers/get_record_field_value.rb
 - lib/elastic_graph/graphql/resolvers/graphql_adapter_builder.rb
-- lib/elastic_graph/graphql/resolvers/list_records.rb
+- lib/elastic_graph/graphql/resolvers/indexed_type_root_fields_resolver.rb
 - lib/elastic_graph/graphql/resolvers/nested_relationships.rb
 - lib/elastic_graph/graphql/resolvers/nested_relationships_source.rb
 - lib/elastic_graph/graphql/resolvers/object.rb
@@ -247,10 +228,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/block/elasticgraph/issues
-  changelog_uri: https://github.com/block/elasticgraph/releases/tag/v1.1.0
-  documentation_uri: https://block.github.io/elasticgraph/api-docs/v1.1.0/
+  changelog_uri: https://github.com/block/elasticgraph/releases/tag/v1.2.0
+  documentation_uri: https://block.github.io/elasticgraph/api-docs/v1.2.0/
   homepage_uri: https://block.github.io/elasticgraph/
-  source_code_uri: https://github.com/block/elasticgraph/tree/v1.1.0/elasticgraph-graphql
+  source_code_uri: https://github.com/block/elasticgraph/tree/v1.2.0/elasticgraph-graphql
   gem_category: core
 rdoc_options: []
 require_paths:
@@ -269,7 +250,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Provides the ElasticGraph GraphQL query engine.
 test_files: []