fix: make count filters on a sub-aggregation work correctly. (#660)

A `count` filter translates into an OpenSearch/Elasticsearch query
filter against a special `__counts` field which is a flat map containing
the counts of each list under the current document context. Our
special handling for it worked everywhere except on a sub-aggregation.
This fixes it by correctly converting the field path to a nested
field path.

Fixes #635.

Author: myronmarston

elasticgraph-graphql/lib/elastic_graph/graphql/aggregation/nested_sub_aggregation.rb

@@ -26,7 +26,7 @@ def nested_path_key
         end
 
         def build_agg_hash(filter_interpreter, parent_queries:)
-          detail = query.build_agg_detail(filter_interpreter, field_path: nested_path, parent_queries: parent_queries)
+          detail = query.build_agg_detail(filter_interpreter, field_path: nested_path, parent_queries: parent_queries, nested: true)
           return {} if detail.nil?
 
           parent_query_names = parent_queries.map(&:name)

elasticgraph-graphql/lib/elastic_graph/graphql/aggregation/query.rb

@@ -57,11 +57,11 @@ def build_agg_hash(filter_interpreter)
           build_agg_detail(filter_interpreter, field_path: [], parent_queries: [])&.clauses || {}
         end
 
-        def build_agg_detail(filter_interpreter, field_path:, parent_queries:)
+        def build_agg_detail(filter_interpreter, field_path:, parent_queries:, nested: false)
           return nil if paginator.desired_page_size.zero? || paginator.paginated_from_singleton_cursor?
           queries = parent_queries + [self] # : ::Array[Query]
 
-          filter_detail(filter_interpreter, field_path) do
+          filter_detail(filter_interpreter, field_path, nested: nested) do
             grouping_adapter.grouping_detail_for(self) do
               Support::HashUtil.disjoint_merge(computations_detail, sub_aggregation_detail(filter_interpreter, queries))
             end
@@ -70,8 +70,14 @@ def build_agg_detail(filter_interpreter, field_path:, parent_queries:)
 
         private
 
-        def filter_detail(filter_interpreter, field_path)
+        def filter_detail(filter_interpreter, field_path, nested: false)
           filtering_field_path = Filtering::FieldPath.of(field_path.filter_map(&:name_in_index))
+
+          # When we're dealing with a nested sub-aggregation, we need to apply the nested transformation
+          # to the filtering field path to ensure count filters work correctly.
+          # This is necessary because nested fields create separate document contexts in Elasticsearch/OpenSearch.
+          filtering_field_path = filtering_field_path.nested if nested
+
           filter_clause = filter_interpreter.build_query([filter].compact, from_field_path: filtering_field_path)
 
           inner_detail = yield

elasticgraph-graphql/sig/elastic_graph/graphql/aggregation/query.rbs

@@ -46,14 +46,16 @@ module ElasticGraph
         def build_agg_detail: (
           Filtering::FilterInterpreter,
           field_path: ::Array[PathSegment],
-          parent_queries: ::Array[Query]
+          parent_queries: ::Array[Query],
+          ?nested: bool
         ) -> AggregationDetail?
 
         private
 
         def filter_detail: (
           Filtering::FilterInterpreter,
-          ::Array[PathSegment]
+          ::Array[PathSegment],
+          ?nested: bool
         ) { () -> AggregationDetail } -> AggregationDetail
 
         def computations_detail: () -> ::Hash[::String, untyped]

elasticgraph-graphql/spec/acceptance/sub_aggregations_spec.rb

@@ -111,6 +111,14 @@ def test_ungrouped_sub_aggregations
           expect(seasons).to eq(count_detail_of(0))
           expect(seasons_player_seasons).to eq(count_detail_of(0))
 
+          # Demonstrate filtering sub-aggregations on `count`.
+          seasons, seasons_player_seasons = count_seasons_and_season_player_seasons(seasons: {filter: {players_nested: {count: {gt: 1}}}})
+          expect(seasons).to eq(count_detail_of(1))
+          expect(seasons_player_seasons).to eq(count_detail_of(3))
+          seasons, seasons_player_seasons = count_seasons_and_season_player_seasons(seasons: {filter: {players_object: {count: {lt: 2}}}})
+          expect(seasons).to eq(count_detail_of(5))
+          expect(seasons_player_seasons).to eq(count_detail_of(0))
+
           player_count, season_count, season_player_count, season_player_season_count = aggregate_sibling_and_deeply_nested_counts
           expect(player_count).to eq(count_detail_of(5))
           expect(season_count).to eq(count_detail_of(6))

elasticgraph-graphql/spec/integration/elastic_graph/graphql/datastore_query/sub_aggregations_spec.rb

@@ -193,6 +193,26 @@ class GraphQL
         }]
       end
 
+      it "allows sub-aggregations to filter on the count of list fields" do
+        query = aggregation_query_of(name: "teams", sub_aggregations: [
+          nested_sub_aggregation_of(path_in_index: ["current_players_nested"], query: sub_aggregation_query_of(name: "current_players_nested", filter: {
+            "seasons_nested" => {LIST_COUNTS_FIELD => {"gt" => 1}}
+          }))
+        ])
+
+        results = search_datastore_aggregations(query, index_def_name: "teams")
+
+        expect(results).to eq [{
+          "doc_count" => 0,
+          "key" => {},
+          "teams:current_players_nested" => {
+            "meta" => outer_meta({"bucket_path" => ["current_players_nested:filtered"]}),
+            "doc_count" => 5,
+            "current_players_nested:filtered" => {"doc_count" => 1}
+          }
+        }]
+      end
+
       it "treats empty filters as `true`" do
         query = aggregation_query_of(name: "teams", sub_aggregations: [
           nested_sub_aggregation_of(path_in_index: ["current_players_nested"], query: sub_aggregation_query_of(name: "current_players_nested", filter: {

elasticgraph-graphql/spec/unit/elastic_graph/graphql/datastore_query/sub_aggregations_spec.rb

@@ -178,6 +178,28 @@ def self.grouped_field_from(agg_hash)
         })
       end
 
+      it "allows sub-aggregations to filter on the count of list fields" do
+        query = new_query(aggregations: [aggregation_query_of(name: "teams", sub_aggregations: [
+          nested_sub_aggregation_of(path_in_index: ["current_players_nested"], query: sub_aggregation_query_of(name: "current_players_nested", filter: {
+            "seasons_nested" => {LIST_COUNTS_FIELD => {"gt" => 1}}
+          }))
+        ])])
+
+        expect(datastore_body_of(query)).to include_aggs({
+          "teams:current_players_nested" => {
+            "meta" => outer_meta({"bucket_path" => ["current_players_nested:filtered"]}),
+            "nested" => {"path" => "current_players_nested"},
+            "aggs" => {
+              "current_players_nested:filtered" => {
+                "filter" => {
+                  bool: {filter: [{range: {"current_players_nested.#{LIST_COUNTS_FIELD}.seasons_nested" => {gt: 1}}}]}
+                }
+              }
+            }
+          }
+        })
+      end
+
       it "treats empty filters treating as `true`" do
         query = new_query(aggregations: [aggregation_query_of(name: "teams", sub_aggregations: [
           nested_sub_aggregation_of(path_in_index: ["current_players_nested"], query: sub_aggregation_query_of(name: "current_players_nested", filter: {