elasticgraph-graphql 0.19.1.0 → 0.19.2.0

data/lib/elastic_graph/graphql/datastore_query.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at
@@ -30,45 +30,8 @@ module ElasticGraph
       :total_document_count_needed, :aggregations, :logger, :filter_interpreter, :routing_picker,
       :index_expression_builder, :default_page_size, :search_index_definitions, :max_page_size,
       :filters, :sort, :document_pagination, :requested_fields, :individual_docs_needed,
-      :monotonic_clock_deadline, :schema_element_names
-    ) {
-      def initialize(
-        filter: nil,
-        filters: nil,
-        sort: nil,
-        document_pagination: nil,
-        aggregations: nil,
-        requested_fields: nil,
-        individual_docs_needed: false,
-        total_document_count_needed: false,
-        monotonic_clock_deadline: nil,
-        **kwargs
-      )
-        # Deal with `:filter` vs `:filters` input and normalize it to a single `filters` set.
-        filters = ::Set.new(filters || [])
-        filters << filter if filter && !filter.empty?
-        filters.freeze
-
-        aggregations ||= {}
-        requested_fields ||= []
-
-        super(
-          filters: filters,
-          sort: sort || [],
-          document_pagination: document_pagination || {},
-          aggregations: aggregations,
-          requested_fields: requested_fields.to_set,
-          individual_docs_needed: individual_docs_needed || !requested_fields.empty?,
-          total_document_count_needed: total_document_count_needed || aggregations.values.any?(&:needs_total_doc_count?),
-          monotonic_clock_deadline: monotonic_clock_deadline,
-          **kwargs
-        )
-
-        if search_index_definitions.empty?
-          raise Errors::SearchFailedError, "Query is invalid, since it contains no `search_index_definitions`."
-        end
-      end
-    }
+      :size_multiplier, :monotonic_clock_deadline, :schema_element_names
+    )
       # Load these files after the `Query` class has been defined, to avoid
       # `TypeError: superclass mismatch for class Query`
       require "elastic_graph/graphql/datastore_query/document_paginator"
@@ -129,34 +92,31 @@ module ElasticGraph
         end
       end
 
-      # Merges the provided query, returning a new combined query object.
-      # Both query objects are left unchanged.
-      def merge(other_query)
-        if search_index_definitions != other_query.search_index_definitions
-          raise ElasticGraph::Errors::InvalidMergeError, "`search_index_definitions` conflict while merging between " \
-            "#{search_index_definitions} and #{other_query.search_index_definitions}"
-        end
-
+      # Merges in the provided attribute overrides, honoring the intended semantics and invariants of `DatastoreQuery`.
+      def merge_with(
+        individual_docs_needed: false,
+        total_document_count_needed: false,
+        filters: [],
+        sort: [],
+        requested_fields: [],
+        document_pagination: {},
+        size_multiplier: 1,
+        monotonic_clock_deadline: nil,
+        aggregations: {}
+      )
         with(
-          individual_docs_needed: individual_docs_needed || other_query.individual_docs_needed,
-          total_document_count_needed: total_document_count_needed || other_query.total_document_count_needed,
-          filters: filters + other_query.filters,
-          sort: merge_attribute(other_query, :sort),
-          requested_fields: requested_fields + other_query.requested_fields,
-          document_pagination: merge_attribute(other_query, :document_pagination),
-          monotonic_clock_deadline: [monotonic_clock_deadline, other_query.monotonic_clock_deadline].compact.min,
-          aggregations: aggregations.merge(other_query.aggregations)
+          individual_docs_needed: self.individual_docs_needed || individual_docs_needed || !requested_fields.empty?,
+          total_document_count_needed: self.total_document_count_needed || total_document_count_needed || aggregations.values.any?(&:needs_total_doc_count?),
+          filters: self.filters + filters,
+          sort: merge_attribute(:sort, sort),
+          requested_fields: self.requested_fields + requested_fields,
+          document_pagination: merge_attribute(:document_pagination, document_pagination),
+          size_multiplier: self.size_multiplier * size_multiplier,
+          monotonic_clock_deadline: [self.monotonic_clock_deadline, monotonic_clock_deadline].compact.min,
+          aggregations: self.aggregations.merge(aggregations)
         )
       end
 
-      # Convenience method for merging when you do not have access to an
-      # `DatastoreQuery::Builder`. Allows you to pass the query options you
-      # would like to merge. As with `#merge`, leaves the original query unchanged
-      # and returns a combined query object.
-      def merge_with(**query_options)
-        merge(with(**query_options))
-      end
-
       # Pairs the multi-search headers and body into a tuple, as per the format required by the datastore:
       # https://www.elastic.co/guide/en/elasticsearch/reference/current/search-multi-search.html#search-multi-search-api-desc
       def to_datastore_msearch_header_and_body
@@ -176,6 +136,10 @@ module ElasticGraph
         ).to_s
       end
 
+      def excluding_indices?
+        search_index_expression.split(",").any? { |expr| expr.start_with?("-") }
+      end
+
       # Returns the name of the datastore cluster as a String where this query should be setn.
       # Unless exactly 1 cluster name is found, this method raises a Errors::ConfigError.
       def cluster_name
@@ -256,6 +220,8 @@ module ElasticGraph
           total_document_count_needed: total_document_count_needed,
           decoded_cursor_factory: decoded_cursor_factory,
           schema_element_names: schema_element_names,
+          size_multiplier: size_multiplier,
+          max_effective_size: search_index_definitions.map { |i| i.max_result_window }.min,
           paginator: Paginator.new(
             default_page_size: default_page_size,
             max_page_size: max_page_size,
@@ -268,11 +234,14 @@ module ElasticGraph
         )
       end
 
+      def effective_size
+        document_paginator.effective_size
+      end
+
       private
 
-      def merge_attribute(other_query, attribute)
+      def merge_attribute(attribute, other_value)
         value = public_send(attribute)
-        other_value = other_query.public_send(attribute)
 
         if value.empty?
           other_value
@@ -281,7 +250,7 @@ module ElasticGraph
         elsif value == other_value
           value
         else
-          logger.warn("Tried to merge two queries that both define `#{attribute}`, using the value from the query being merged: #{value}, #{other_value}")
+          logger.warn("Tried to merge conflicting values of `#{attribute}`; using the value from the merge override: #{value} (vs. #{other_value})")
           other_value
         end
       end
@@ -344,11 +313,7 @@ module ElasticGraph
 
       # Encapsulates dependencies of `Query`, giving us something we can expose off of `application`
       # to build queries when desired.
-      class Builder < Support::MemoizableData.define(:runtime_metadata, :logger, :filter_node_interpreter, :query_defaults)
-        def self.with(runtime_metadata:, logger:, filter_node_interpreter:, **query_defaults)
-          new(runtime_metadata:, logger:, filter_node_interpreter:, query_defaults:)
-        end
-
+      class Builder < Support::MemoizableData.define(:runtime_metadata, :logger, :filter_interpreter, :filter_node_interpreter, :default_page_size, :max_page_size)
         def routing_picker
           @routing_picker ||= RoutingPicker.new(
             filter_node_interpreter: filter_node_interpreter,
@@ -363,13 +328,40 @@ module ElasticGraph
           )
         end
 
-        def new_query(**options)
+        def new_query(
+          search_index_definitions:,
+          filters: [],
+          sort: [],
+          document_pagination: {},
+          size_multiplier: 1,
+          aggregations: {},
+          requested_fields: [],
+          individual_docs_needed: false,
+          total_document_count_needed: false,
+          monotonic_clock_deadline: nil
+        )
+          if search_index_definitions.empty?
+            raise Errors::SearchFailedError, "Query is invalid, since it contains no `search_index_definitions`."
+          end
+
           DatastoreQuery.new(
             routing_picker: routing_picker,
             index_expression_builder: index_expression_builder,
             logger: logger,
             schema_element_names: runtime_metadata.schema_element_names,
-            **query_defaults.merge(options)
+            search_index_definitions: search_index_definitions,
+            filters: filters.to_set,
+            sort: sort,
+            document_pagination: document_pagination,
+            size_multiplier: size_multiplier,
+            aggregations: aggregations,
+            requested_fields: requested_fields.to_set,
+            individual_docs_needed: individual_docs_needed || !requested_fields.empty?,
+            total_document_count_needed: total_document_count_needed || aggregations.values.any?(&:needs_total_doc_count?),
+            monotonic_clock_deadline: monotonic_clock_deadline,
+            filter_interpreter: filter_interpreter,
+            default_page_size: default_page_size,
+            max_page_size: max_page_size
           )
         end
       end

data/lib/elastic_graph/graphql/datastore_response/document.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at

data/lib/elastic_graph/graphql/datastore_response/search_response.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at
@@ -9,6 +9,7 @@
 require "elastic_graph/errors"
 require "elastic_graph/graphql/decoded_cursor"
 require "elastic_graph/graphql/datastore_response/document"
+require "elastic_graph/support/hash_util"
 require "forwardable"
 
 module ElasticGraph
@@ -17,15 +18,17 @@ module ElasticGraph
       # Represents a search response from the datastore. Exposes both the raw metadata
       # provided by the datastore and the collection of documents. Can be treated as a
       # collection of documents when you don't care about the metadata.
-      class SearchResponse < ::Data.define(:raw_data, :metadata, :documents, :total_document_count)
+      class SearchResponse < ::Data.define(:raw_data, :metadata, :documents, :total_document_count, :aggregations_unavailable_reason, :decoded_cursor_factory)
         include Enumerable
         extend Forwardable
 
+        private :raw_data
+
         def_delegators :documents, :each, :to_a, :size, :empty?
 
         EXCLUDED_METADATA_KEYS = %w[hits aggregations].freeze
 
-        def self.build(raw_data, decoded_cursor_factory: DecodedCursor::Factory::Null)
+        def self.build(raw_data, decoded_cursor_factory: DecodedCursor::Factory::Null, aggregations_unavailable_reason: nil)
           documents = raw_data.fetch("hits").fetch("hits").map do |doc|
             Document.build(doc, decoded_cursor_factory: decoded_cursor_factory)
           end
@@ -50,23 +53,94 @@ module ElasticGraph
           total_document_count = metadata.dig("hits", "total", "value")
 
           new(
-            raw_data: raw_data,
-            metadata: metadata,
-            documents: documents,
-            total_document_count: total_document_count
+            raw_data:,
+            metadata:,
+            documents:,
+            total_document_count:,
+            aggregations_unavailable_reason:,
+            decoded_cursor_factory:
           )
         end
 
+        def self.synthesize_from_ids(index, ids, decoded_cursor_factory: DecodedCursor::Factory::Null)
+          hits = ids.map do |id|
+            {
+              "_index" => index,
+              "_type" => "_doc",
+              "_id" => id,
+              "_score" => nil,
+              "_source" => {"id" => id},
+              "sort" => [id]
+            }
+          end
+
+          raw_data = {
+            "took" => 0,
+            "timed_out" => false,
+            "_shards" => {
+              "total" => 0,
+              "successful" => 0,
+              "skipped" => 0,
+              "failed" => 0
+            },
+            "hits" => {
+              "total" => {
+                "value" => ids.size,
+                "relation" => "eq"
+              },
+              "max_score" => nil,
+              "hits" => hits
+            }
+          }
+
+          build(raw_data, decoded_cursor_factory: decoded_cursor_factory)
+        end
+
         # Benign empty response that can be used in place of datastore response errors as needed.
         RAW_EMPTY = {"hits" => {"hits" => [], "total" => {"value" => 0}}}.freeze
         EMPTY = build(RAW_EMPTY)
 
+        # Returns a response filtered to results that have matching `values` at the given `field_path`, limiting
+        # the results to the first `size` results.
+        #
+        # This is designed for use in situations where we have N different datastore queries which are identical
+        # except for differing filter values. For efficiency, we combine those queries into a single query that
+        # filters on the set union of values. We can then use this method to "split" the single response into what
+        # the separate responses would have been if we hadn't combined into a single query.
+        def filter_results(field_path, values, size)
+          filter =
+            if field_path == ["id"]
+              # `id` filtering is a very common case, and we want to avoid having to request
+              # `id` within `_source`, given it's available as `_id`.
+              ->(hit) { values.include?(hit.fetch("_id")) }
+            else
+              ->(hit) { values.intersect?(Support::HashUtil.fetch_leaf_values_at_path(hit.fetch("_source"), field_path).to_set) }
+            end
+
+          hits = raw_data.fetch("hits").fetch("hits").select(&filter).first(size)
+          updated_raw_data = Support::HashUtil.deep_merge(raw_data, {"hits" => {"hits" => hits, "total" => nil}})
+
+          SearchResponse.build(
+            updated_raw_data,
+            decoded_cursor_factory: decoded_cursor_factory,
+            aggregations_unavailable_reason: "aggregations cannot be provided accurately on a search response filtered in memory"
+          )
+        end
+
         def docs_description
           (documents.size < 3) ? documents.inspect : "[#{documents.first}, ..., #{documents.last}]"
         end
 
-        def total_document_count
-          super || raise(Errors::CountUnavailableError, "#{__method__} is unavailable; set `query.total_document_count_needed = true` to make it available")
+        def total_document_count(default: nil)
+          super() || default || raise(Errors::CountUnavailableError, "#{__method__} is unavailable; set `query.total_document_count_needed = true` to make it available")
+        end
+
+        def aggregations
+          if (reason = aggregations_unavailable_reason)
+            raise Errors::AggregationsUnavailableError, "Aggregations are unavailable on this search response: #{reason}."
+          end
+
+          raw_data["aggregations"] || {}
         end
 
         def to_s

data/lib/elastic_graph/graphql/datastore_search_router.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at
@@ -28,6 +28,8 @@ module ElasticGraph
         @config = config
       end
 
+      INDICES_NOT_CONFIGURED_MESSAGE = "The datastore indices have not been configured. They must be configured before ElasticGraph can serve queries."
+
       # 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)
@@ -78,9 +80,22 @@ module ElasticGraph
             [response["took"], queries_for_cluster.zip(ordered_responses)]
           end
 
-          query_tracker.record_datastore_query_duration_ms(
-            client: @monotonic_clock.now_in_ms - datastore_query_started_at,
-            server: server_took_and_results.map(&:first).compact.max
+          queried_shard_count = server_took_and_results.reduce(0) do |outer_accum, (query, queries_and_responses)|
+            outer_accum + queries_and_responses.reduce(0) do |inner_accum, (query, response)|
+              shards_total = response.dig("_shards", "total")
+
+              if shards_total == 0 && !query.excluding_indices?
+                raise ::GraphQL::ExecutionError, INDICES_NOT_CONFIGURED_MESSAGE
+              end
+
+              inner_accum + (shards_total || 0)
+            end
+          end
+
+          query_tracker.record_datastore_query_metrics(
+            client_duration_ms: @monotonic_clock.now_in_ms - datastore_query_started_at,
+            server_duration_ms: server_took_and_results.map(&:first).compact.max,
+            queried_shard_count: queried_shard_count
           )
 
           server_took_and_results.flat_map(&:last).to_h.tap do |responses_by_query|

data/lib/elastic_graph/graphql/decoded_cursor.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at

data/lib/elastic_graph/graphql/filtering/boolean_query.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at

data/lib/elastic_graph/graphql/filtering/field_path.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at

data/lib/elastic_graph/graphql/filtering/filter_args_translator.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at
@@ -37,7 +37,7 @@ module ElasticGraph
           when ::Hash
             filter_object.to_h do |key, value|
               field = parent_type.field_named(key)
-              [field.name_in_index.to_s, convert(field.type.unwrap_fully, value)]
+              [field.name_in_index, convert(field.type.unwrap_fully, value)]
             end
           when ::Array
             filter_object.map { |value| convert(parent_type, value) }

data/lib/elastic_graph/graphql/filtering/filter_interpreter.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at
@@ -219,10 +219,14 @@ module ElasticGraph
         end
 
         def process_all_of_expression(bool_node, expressions, field_path)
-          # `all_of` represents an AND. AND is the default way that `process_filter_hash` combines
-          # filters so we just have to call it for each sub-expression.
+          # `all_of` represents an AND of multiple subexpressions.
+          # To achieve this, we build a new bool sub-filter for each subexpression and push it onto
+          # the parent’s `:filter` array. Each item in `:filter` is independently required (AND).
           expressions.each do |sub_expression|
-            process_filter_hash(bool_node, sub_expression, field_path)
+            sub_filter = build_bool_hash do |sub_bool_node|
+              process_filter_hash(sub_bool_node, sub_expression, field_path)
+            end
+            bool_node[:filter] << sub_filter if sub_filter
           end
         end
 
@@ -339,7 +343,8 @@ module ElasticGraph
         end
 
         def build_bool_hash(&block)
-          bool_node = Hash.new { |h, k| h[k] = [] }.tap(&block)
+          bool_node = Hash.new { |h, k| h[k] = [] } # : stringOrSymbolHash
+          bool_node.tap(&block)
 
           # To treat "empty" filter predicates as `true` we need to return `nil` here.
           return nil if bool_node.empty?

data/lib/elastic_graph/graphql/filtering/filter_node_interpreter.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at
@@ -168,7 +168,7 @@ module ElasticGraph
           when ::Array
             value.map { |v| to_datastore_value(v) }
           when Schema::EnumValue
-            value.name.to_s
+            value.name
           else
             value
           end

data/lib/elastic_graph/graphql/filtering/filter_value_set_extractor.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at
@@ -99,6 +99,8 @@ module ElasticGraph
             filter_value_set_for_filter_hash(filter_value, target_field_path_parts, traversed_field_path_parts + [field_or_op], negate: negate)
           when :any_of
             filter_value_set_for_any_of(filter_value, target_field_path_parts, traversed_field_path_parts, negate: negate)
+          when :all_of
+            filter_value_set_for_all_of(filter_value, target_field_path_parts, traversed_field_path_parts, negate: negate)
           when :operator
             # Check to make sure the operator applies to the target field. If not, we have no information
             # in this clause. The set is unbounded, and may have exclusions.
@@ -106,7 +108,7 @@ module ElasticGraph
 
             set = filter_value_set_for_field_filter(field_or_op, filter_value)
             negate ? set.negate : set
-          when :all_of, :list_any_filter, :list_count, :unknown
+          when :list_any_filter, :list_count, :unknown
             # We have no information in this clause. The set is unbounded, and may have exclusions.
             UnboundedSetWithExclusions
           else
@@ -134,6 +136,19 @@ module ElasticGraph
           end
         end
 
+        # Determines the set of filter values for an `all_of` clause, which is used for ANDing multiple filters together.
+        def filter_value_set_for_all_of(filter_hashes, target_field_path_parts, traversed_field_path_parts, negate:)
+          # all_of: [] => match all values
+          if filter_hashes.empty?
+            return negate ? @empty_set : @all_values_set
+          end
+
+          # With all_of (AND), we do an intersection of subfilters
+          map_reduce_sets(filter_hashes, :intersection, negate: negate) do |filter_hash|
+            filter_value_set_for_filter_hash(filter_hash, target_field_path_parts, traversed_field_path_parts, negate: negate)
+          end
+        end
+
         # Determines the set of filter values for a single filter on a single field.
         def filter_value_set_for_field_filter(filter_op, filter_value)
           operator_name = @schema_names.canonical_name_for(filter_op)

data/lib/elastic_graph/graphql/filtering/range_query.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at

data/lib/elastic_graph/graphql/http_endpoint.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at
@@ -227,7 +227,7 @@ module ElasticGraph
     # Steep weirdly expects them here...
     # @dynamic initialize, config, logger, runtime_metadata, graphql_schema_string, datastore_core, clock
     # @dynamic graphql_http_endpoint, graphql_query_executor, schema, datastore_search_router, filter_interpreter, filter_node_interpreter
-    # @dynamic datastore_query_builder, graphql_gem_plugins, graphql_resolvers, datastore_query_adapters, monotonic_clock
+    # @dynamic datastore_query_builder, graphql_gem_plugins, graphql_adapter, resolver_query_adapter, named_graphql_resolvers, datastore_query_adapters, monotonic_clock
     # @dynamic load_dependencies_eagerly, self.from_parsed_yaml, filter_args_translator, sub_aggregation_grouping_adapter
   end
 end

data/lib/elastic_graph/graphql/monkey_patches/schema_field.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at

data/lib/elastic_graph/graphql/monkey_patches/schema_object.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at

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

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at

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

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at

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

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at
@@ -14,13 +14,28 @@ module ElasticGraph
       # need to satisfy the GraphQL query. This results in more efficient datastore queries,
       # similar to doing `SELECT f1, f2, ...` instead of `SELECT *` for a SQL query.
       class RequestedFields
+        # Partially applied `RequestedFields` -- essentially the `RequestedFields` without the schema,
+        # so that it can be instantiated before the `Schema` instance exists, instead providing it from
+        # `context` at query time.
+        class WithoutSchema
+          def call(field:, query:, lookahead:, args:, context:)
+            return query if field.type.unwrap_fully.indexed_aggregation?
+
+            RequestedFields.new(context.fetch(:elastic_graph_schema)).call(
+              field: field,
+              query: query,
+              lookahead: lookahead,
+              args: args,
+              context: context
+            )
+          end
+        end
+
         def initialize(schema)
           @schema = schema
         end
 
         def call(field:, query:, lookahead:, args:, context:)
-          return query if field.type.unwrap_fully.indexed_aggregation?
-
           attributes = query_attributes_for(field: field, lookahead: lookahead)
           query.merge_with(**attributes)
         end

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

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at

data/lib/elastic_graph/graphql/query_details_tracker.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at
@@ -21,6 +21,7 @@ module ElasticGraph
       :query_counts_per_datastore_request,
       :datastore_query_server_duration_ms,
       :datastore_query_client_duration_ms,
+      :queried_shard_count,
       :mutex
     )
       def self.empty
@@ -31,6 +32,7 @@ module ElasticGraph
           query_counts_per_datastore_request: [],
           datastore_query_server_duration_ms: 0,
           datastore_query_client_duration_ms: 0,
+          queried_shard_count: 0,
           mutex: ::Thread::Mutex.new
         )
       end
@@ -49,12 +51,19 @@ module ElasticGraph
         end
       end
 
-      def record_datastore_query_duration_ms(client:, server:)
+      def record_datastore_query_metrics(client_duration_ms:, server_duration_ms:, queried_shard_count:)
         mutex.synchronize do
-          self.datastore_query_client_duration_ms += client
-          self.datastore_query_server_duration_ms += server if server
+          self.datastore_query_client_duration_ms += client_duration_ms
+          self.datastore_query_server_duration_ms += server_duration_ms if server_duration_ms
+          self.queried_shard_count += queried_shard_count
         end
       end
+
+      # Indicates how long was spent on transport between the client and the datastore server, including
+      # network time, JSON serialization time, etc.
+      def datastore_request_transport_duration_ms
+        datastore_query_client_duration_ms - datastore_query_server_duration_ms
+      end
     end
   end
 end