elasticgraph-graphql 0.18.0.2 → 0.18.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b80c95effea6c96d77f52275854dcf2ef14fa9b56c56cbca44fef5b5e34da5d
-  data.tar.gz: 6af6c4269f7d9b4822a16e0007c24574593261a585cc7de9227ec3584c50a5ed
+  metadata.gz: b0cb73d5ec2940bb792cbcada0c615dd1415de774bb9111ffe09ae293cf2de38
+  data.tar.gz: fb0f23546ee15fd3c9f434518dde7ccb79df0838795392d6b0a8c9e60df01667
 SHA512:
-  metadata.gz: 33c540e6691fa35958a4b8c01984909f36a12092e05bb78e4cf91424a555d2932b79cdb50e8007756c2bd7d4a44bc176b36a7363cf5e5b2be75f3d5475d616d7
-  data.tar.gz: 9ee9a9790c301d17f6467413d2ad02f6e01fd2305b5989eaed5fcbd78fdd8d84b9b8f21ef14cdd109444675a6e63df737555be7eb34be988bb44359a834ab0ea
+  metadata.gz: 4c21c60909ba34c7034b2c5506288f54d4e29aa715e9741e1f88a046b54d6a694082b657c00aa495da7d28eb771bec28c2a23d0c10b3c5dbfa46e20088c9802f
+  data.tar.gz: ecbd8f84362640638e36384875d43c8a9443a413bb407dd2fca5e1d18792bfe618ac5b15c14a9d0c7d2656b7234620d73ce95078bc18ed4cc72eecbec4958ad3

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

@@ -6,30 +6,27 @@
 #
 # frozen_string_literal: true
 
-require "elastic_graph/constants"
-require "elastic_graph/graphql/filtering/boolean_query"
 require "elastic_graph/graphql/filtering/field_path"
-require "elastic_graph/graphql/filtering/range_query"
-require "elastic_graph/graphql/schema/enum_value"
+require "elastic_graph/graphql/filtering/filter_node_interpreter"
 require "elastic_graph/support/graphql_formatter"
 require "elastic_graph/support/memoizable_data"
-require "elastic_graph/support/time_util"
 require "graphql"
 
 module ElasticGraph
   class GraphQL
     module Filtering
-      # Contains all query logic related to filtering. Not tested directly; tests drive the `Query` interface instead.
+      # Responsible for interpreting a query's overall `filter`. Not tested directly; tests drive the `Query` interface instead.
+      #
       # For more info on how this works, see:
       # https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-bool-query.html
       # https://www.elastic.co/blog/lost-in-translation-boolean-operations-and-filters-in-the-bool-query
-      FilterInterpreter = Support::MemoizableData.define(:runtime_metadata, :schema_names, :logger) do
+      FilterInterpreter = Support::MemoizableData.define(:filter_node_interpreter, :schema_names, :logger) do
         # @implements FilterInterpreter
 
-        def initialize(runtime_metadata:, logger:)
+        def initialize(filter_node_interpreter:, logger:)
           super(
-            runtime_metadata: runtime_metadata,
-            schema_names: runtime_metadata.schema_element_names,
+            filter_node_interpreter: filter_node_interpreter,
+            schema_names: filter_node_interpreter.schema_names,
             logger: logger
           )
         end
@@ -49,12 +46,12 @@ module ElasticGraph
         end
 
         def to_s
-          # The inspect/to_s output of `runtime_metadata` and `logger` can be quite large and noisy. We generally don't care about
+          # The inspect/to_s output of `filter_node_interpreter` and `logger` can be quite large and noisy. We generally don't care about
           # those details but want to be able to tell at a glance if two `FilterInterpreter` instances are equal or not--and, if they
           # aren't equal, which part is responsible for the inequality.
           #
           # Using the hash of the two initialize args provides us with that.
-          "#<data #{FilterInterpreter.name} runtime_metadata=(hash: #{runtime_metadata.hash}) logger=(hash: #{logger.hash})>"
+          "#<data #{FilterInterpreter.name} filter_node_interpreter=(hash: #{filter_node_interpreter.hash}) logger=(hash: #{logger.hash})>"
         end
         alias_method :inspect, :to_s
 
@@ -67,7 +64,7 @@ module ElasticGraph
             # below having to be aware of possible `nil` predicates.
             expression = expression.compact if expression.is_a?(::Hash)
 
-            case identify_expression_type(field_or_op, expression)
+            case filter_node_interpreter.identify_node_type(field_or_op, expression)
             when :empty
               # This is an "empty" filter predicate and we can ignore it.
             when :not
@@ -90,23 +87,11 @@ module ElasticGraph
           end
         end
 
-        def identify_expression_type(field_or_op, expression)
-          return :empty if expression.nil? || expression == {}
-          return :not if field_or_op == schema_names.not
-          return :list_any_filter if field_or_op == schema_names.any_satisfy
-          return :all_of if field_or_op == schema_names.all_of
-          return :any_of if field_or_op == schema_names.any_of
-          return :operator if filter_operators.key?(field_or_op)
-          return :list_count if field_or_op == LIST_COUNTS_FIELD
-          return :sub_field if expression.is_a?(::Hash)
-          :unknown
-        end
-
         # Indicates if the given `expression` applies filtering to subfields or just applies
         # operators at the current field path.
         def filters_on_sub_fields?(expression)
           expression.any? do |field_or_op, sub_expression|
-            case identify_expression_type(field_or_op, sub_expression)
+            case filter_node_interpreter.identify_node_type(field_or_op, sub_expression)
             when :sub_field
               true
             when :not, :list_any_filter
@@ -165,7 +150,9 @@ module ElasticGraph
             process_filter_hash(inner_node, filter, field_path.nested)
           end
 
-          bool_node[:filter] << {nested: {path: field_path.from_root.join("."), query: sub_filter}}
+          if sub_filter
+            bool_node[:filter] << {nested: {path: field_path.from_root.join("."), query: sub_filter}}
+          end
         end
 
         # On a list-of-leaf-values field, `any_satisfy` doesn't _do_ anything: it just expresses
@@ -228,7 +215,7 @@ module ElasticGraph
           # `operator` is a filtering operator, and `expression` is the value the filtering
           # operator should be applied to. The `op_applicator` lambda, when called, will
           # return a Clause instance (defined in this module).
-          bool_query = filter_operators.fetch(operator).call(field_path.from_root.join("."), expression)
+          bool_query = filter_node_interpreter.filter_operators.fetch(operator).call(field_path.from_root.join("."), expression)
           bool_query&.merge_into(bool_node)
         end
 
@@ -305,7 +292,7 @@ module ElasticGraph
               process_filter_hash(inner_node, expression, field_path)
             end
 
-            bool_node[:filter] << sub_filter
+            bool_node[:filter] << sub_filter if sub_filter
           else
             process_filter_hash(bool_node, expression, field_path)
           end
@@ -367,146 +354,6 @@ module ElasticGraph
           end
         end
 
-        def filter_operators
-          @filter_operators ||= build_filter_operators(runtime_metadata)
-        end
-
-        def build_filter_operators(runtime_metadata)
-          schema_names = runtime_metadata.schema_element_names
-
-          filter_by_time_of_day_script_id = runtime_metadata
-            .static_script_ids_by_scoped_name
-            .fetch("filter/by_time_of_day")
-
-          {
-            schema_names.equal_to_any_of => ->(field_name, value) {
-              values = to_datastore_value(value.compact.uniq) # : ::Array[untyped]
-
-              equality_sub_expression =
-                if field_name == "id"
-                  # Use specialized "ids" query when querying on ID field.
-                  # See: https://www.elastic.co/guide/en/elasticsearch/reference/7.15/query-dsl-ids-query.html
-                  #
-                  # We reject empty strings because we otherwise get an error from the datastore:
-                  # "failed to create query: Ids can't be empty"
-                  {ids: {values: values - [""]}}
-                else
-                  {terms: {field_name => values}}
-                end
-
-              exists_sub_expression = {exists: {"field" => field_name}}
-
-              if !value.empty? && value.all?(&:nil?)
-                BooleanQuery.new(:must_not, [{bool: {filter: [exists_sub_expression]}}])
-              elsif value.include?(nil)
-                BooleanQuery.filter({bool: {
-                  minimum_should_match: 1,
-                  should: [
-                    {bool: {filter: [equality_sub_expression]}},
-                    {bool: {must_not: [{bool: {filter: [exists_sub_expression]}}]}}
-                  ]
-                }})
-              else
-                BooleanQuery.filter(equality_sub_expression)
-              end
-            },
-            schema_names.gt => ->(field_name, value) { RangeQuery.new(field_name, :gt, value) },
-            schema_names.gte => ->(field_name, value) { RangeQuery.new(field_name, :gte, value) },
-            schema_names.lt => ->(field_name, value) { RangeQuery.new(field_name, :lt, value) },
-            schema_names.lte => ->(field_name, value) { RangeQuery.new(field_name, :lte, value) },
-            schema_names.matches => ->(field_name, value) { BooleanQuery.must({match: {field_name => value}}) },
-            schema_names.matches_query => ->(field_name, value) do
-              allowed_edits_per_term = value.fetch(schema_names.allowed_edits_per_term).runtime_metadata.datastore_abbreviation
-
-              BooleanQuery.must(
-                {
-                  match: {
-                    field_name => {
-                      query: value.fetch(schema_names.query),
-                      # This is always a string field, even though the value is often an integer
-                      fuzziness: allowed_edits_per_term.to_s,
-                      operator: value[schema_names.require_all_terms] ? "AND" : "OR"
-                    }
-                  }
-                }
-              )
-            end,
-            schema_names.matches_phrase => ->(field_name, value) {
-              BooleanQuery.must(
-                {
-                  match_phrase_prefix: {
-                    field_name => {
-                      query: value.fetch(schema_names.phrase)
-                    }
-                  }
-                }
-              )
-            },
-
-            # This filter operator wraps a geo distance query:
-            # https://www.elastic.co/guide/en/elasticsearch/reference/7.10/query-dsl-geo-distance-query.html
-            schema_names.near => ->(field_name, value) do
-              unit_abbreviation = value.fetch(schema_names.unit).runtime_metadata.datastore_abbreviation
-
-              BooleanQuery.filter({geo_distance: {
-                "distance" => "#{value.fetch(schema_names.max_distance)}#{unit_abbreviation}",
-                field_name => {
-                  "lat" => value.fetch(schema_names.latitude),
-                  "lon" => value.fetch(schema_names.longitude)
-                }
-              }})
-            end,
-
-            schema_names.time_of_day => ->(field_name, value) do
-              # To filter on time of day, we use the `filter/by_time_of_day` script. We accomplish
-              # this with a script because Elasticsearch/OpenSearch do not support this natively, and it's
-              # incredibly hard to implement correctly with respect to time zones without using a
-              # script. We considered indexing the `time_of_day` as a separate index field
-              # that we could directly filter on, but since we need the time of day to be relative
-              # to a specific time zone, there's no way to make that work with the reality of
-              # daylight savings time. For example, the `America/Los_Angeles` time zone has a -07:00
-              # UTC offset for part of the year and a `America/Los_Angeles` -08:00 UTC offset for
-              # part of the year. In a script we can use Java time zone APIs to handle this correctly.
-              params = {
-                field: field_name,
-                equal_to_any_of: list_of_nanos_of_day_from(value, schema_names.equal_to_any_of),
-                gt: nano_of_day_from(value, schema_names.gt),
-                gte: nano_of_day_from(value, schema_names.gte),
-                lt: nano_of_day_from(value, schema_names.lt),
-                lte: nano_of_day_from(value, schema_names.lte),
-                time_zone: value[schema_names.time_zone]
-              }.compact
-
-              # If there are no comparison operators, return `nil` instead of a `Clause` so that we avoid
-              # invoking the script for no reason. Note that `field` and `time_zone` will always be in
-              # `params` so we can't just check for an empty hash here.
-              if (params.keys - [:field, :time_zone]).any?
-                BooleanQuery.filter({script: {script: {id: filter_by_time_of_day_script_id, params: params}}})
-              end
-            end
-          }.freeze
-        end
-
-        def to_datastore_value(value)
-          case value
-          when ::Array
-            value.map { |v| to_datastore_value(v) }
-          when Schema::EnumValue
-            value.name.to_s
-          else
-            value
-          end
-        end
-
-        def nano_of_day_from(value, field)
-          local_time = value[field]
-          Support::TimeUtil.nano_of_day_from_local_time(local_time) if local_time
-        end
-
-        def list_of_nanos_of_day_from(value, field)
-          value[field]&.map { |t| Support::TimeUtil.nano_of_day_from_local_time(t) }
-        end
-
         # Counts how many clauses in `bool_query` are required to match for a document to be a search hit.
         def required_matching_clause_count(bool_query)
           bool_query.reduce(0) do |count, (occurrence, clauses)|

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

@@ -0,0 +1,181 @@
+# Copyright 2024 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
+
+require "elastic_graph/constants"
+require "elastic_graph/graphql/filtering/boolean_query"
+require "elastic_graph/graphql/filtering/range_query"
+require "elastic_graph/graphql/schema/enum_value"
+require "elastic_graph/support/memoizable_data"
+require "elastic_graph/support/time_util"
+
+module ElasticGraph
+  class GraphQL
+    module Filtering
+      # Responsible for interpreting a single `node` in a `filter` expression.
+      FilterNodeInterpreter = Support::MemoizableData.define(:runtime_metadata, :schema_names) do
+        # @implements FilterNodeInterpreter
+
+        def initialize(runtime_metadata:)
+          super(runtime_metadata: runtime_metadata, schema_names: runtime_metadata.schema_element_names)
+        end
+
+        def identify_node_type(field_or_op, sub_expression)
+          return :empty if sub_expression.nil? || sub_expression == {}
+          return :not if field_or_op == schema_names.not
+          return :list_any_filter if field_or_op == schema_names.any_satisfy
+          return :all_of if field_or_op == schema_names.all_of
+          return :any_of if field_or_op == schema_names.any_of
+          return :operator if filter_operators.key?(field_or_op)
+          return :list_count if field_or_op == LIST_COUNTS_FIELD
+          return :sub_field if sub_expression.is_a?(::Hash)
+          :unknown
+        end
+
+        def filter_operators
+          @filter_operators ||= build_filter_operators(runtime_metadata)
+        end
+
+        private
+
+        def build_filter_operators(runtime_metadata)
+          filter_by_time_of_day_script_id = runtime_metadata
+            .static_script_ids_by_scoped_name
+            .fetch("filter/by_time_of_day")
+
+          {
+            schema_names.equal_to_any_of => ->(field_name, value) {
+              values = to_datastore_value(value.compact.uniq) # : ::Array[untyped]
+
+              equality_sub_expression =
+                if field_name == "id"
+                  # Use specialized "ids" query when querying on ID field.
+                  # See: https://www.elastic.co/guide/en/elasticsearch/reference/7.15/query-dsl-ids-query.html
+                  #
+                  # We reject empty strings because we otherwise get an error from the datastore:
+                  # "failed to create query: Ids can't be empty"
+                  {ids: {values: values - [""]}}
+                else
+                  {terms: {field_name => values}}
+                end
+
+              exists_sub_expression = {exists: {"field" => field_name}}
+
+              if !value.empty? && value.all?(&:nil?)
+                BooleanQuery.new(:must_not, [{bool: {filter: [exists_sub_expression]}}])
+              elsif value.include?(nil)
+                BooleanQuery.filter({bool: {
+                  minimum_should_match: 1,
+                  should: [
+                    {bool: {filter: [equality_sub_expression]}},
+                    {bool: {must_not: [{bool: {filter: [exists_sub_expression]}}]}}
+                  ]
+                }})
+              else
+                BooleanQuery.filter(equality_sub_expression)
+              end
+            },
+            schema_names.gt => ->(field_name, value) { RangeQuery.new(field_name, :gt, value) },
+            schema_names.gte => ->(field_name, value) { RangeQuery.new(field_name, :gte, value) },
+            schema_names.lt => ->(field_name, value) { RangeQuery.new(field_name, :lt, value) },
+            schema_names.lte => ->(field_name, value) { RangeQuery.new(field_name, :lte, value) },
+            schema_names.matches => ->(field_name, value) { BooleanQuery.must({match: {field_name => value}}) },
+            schema_names.matches_query => ->(field_name, value) do
+              allowed_edits_per_term = value.fetch(schema_names.allowed_edits_per_term).runtime_metadata.datastore_abbreviation
+
+              BooleanQuery.must(
+                {
+                  match: {
+                    field_name => {
+                      query: value.fetch(schema_names.query),
+                      # This is always a string field, even though the value is often an integer
+                      fuzziness: allowed_edits_per_term.to_s,
+                      operator: value[schema_names.require_all_terms] ? "AND" : "OR"
+                    }
+                  }
+                }
+              )
+            end,
+            schema_names.matches_phrase => ->(field_name, value) {
+              BooleanQuery.must(
+                {
+                  match_phrase_prefix: {
+                    field_name => {
+                      query: value.fetch(schema_names.phrase)
+                    }
+                  }
+                }
+              )
+            },
+
+            # This filter operator wraps a geo distance query:
+            # https://www.elastic.co/guide/en/elasticsearch/reference/7.10/query-dsl-geo-distance-query.html
+            schema_names.near => ->(field_name, value) do
+              unit_abbreviation = value.fetch(schema_names.unit).runtime_metadata.datastore_abbreviation
+
+              BooleanQuery.filter({geo_distance: {
+                "distance" => "#{value.fetch(schema_names.max_distance)}#{unit_abbreviation}",
+                field_name => {
+                  "lat" => value.fetch(schema_names.latitude),
+                  "lon" => value.fetch(schema_names.longitude)
+                }
+              }})
+            end,
+
+            schema_names.time_of_day => ->(field_name, value) do
+              # To filter on time of day, we use the `filter/by_time_of_day` script. We accomplish
+              # this with a script because Elasticsearch/OpenSearch do not support this natively, and it's
+              # incredibly hard to implement correctly with respect to time zones without using a
+              # script. We considered indexing the `time_of_day` as a separate index field
+              # that we could directly filter on, but since we need the time of day to be relative
+              # to a specific time zone, there's no way to make that work with the reality of
+              # daylight savings time. For example, the `America/Los_Angeles` time zone has a -07:00
+              # UTC offset for part of the year and a `America/Los_Angeles` -08:00 UTC offset for
+              # part of the year. In a script we can use Java time zone APIs to handle this correctly.
+              params = {
+                field: field_name,
+                equal_to_any_of: list_of_nanos_of_day_from(value, schema_names.equal_to_any_of),
+                gt: nano_of_day_from(value, schema_names.gt),
+                gte: nano_of_day_from(value, schema_names.gte),
+                lt: nano_of_day_from(value, schema_names.lt),
+                lte: nano_of_day_from(value, schema_names.lte),
+                time_zone: value[schema_names.time_zone]
+              }.compact
+
+              # If there are no comparison operators, return `nil` instead of a `Clause` so that we avoid
+              # invoking the script for no reason. Note that `field` and `time_zone` will always be in
+              # `params` so we can't just check for an empty hash here.
+              if (params.keys - [:field, :time_zone]).any?
+                BooleanQuery.filter({script: {script: {id: filter_by_time_of_day_script_id, params: params}}})
+              end
+            end
+          }.freeze
+        end
+
+        def to_datastore_value(value)
+          case value
+          when ::Array
+            value.map { |v| to_datastore_value(v) }
+          when Schema::EnumValue
+            value.name.to_s
+          else
+            value
+          end
+        end
+
+        def nano_of_day_from(value, field)
+          local_time = value[field]
+          Support::TimeUtil.nano_of_day_from_local_time(local_time) if local_time
+        end
+
+        def list_of_nanos_of_day_from(value, field)
+          value[field]&.map { |t| Support::TimeUtil.nano_of_day_from_local_time(t) }
+        end
+      end
+    end
+  end
+end

data/lib/elastic_graph/graphql/http_endpoint.rb

@@ -222,7 +222,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
+    # @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 load_dependencies_eagerly, self.from_parsed_yaml, filter_args_translator, sub_aggregation_grouping_adapter
   end

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

@@ -13,7 +13,7 @@ require "elastic_graph/support/memoizable_data"
 module ElasticGraph
   class GraphQL
     class QueryAdapter
-      class Filters < Support::MemoizableData.define(:schema_element_names, :filter_args_translator)
+      class Filters < Support::MemoizableData.define(:schema_element_names, :filter_args_translator, :filter_node_interpreter)
         def call(field:, query:, args:, lookahead:, context:)
           filter_from_args = filter_args_translator.translate_filter_args(field: field, args: args)
           automatic_filter = build_automatic_filter(filter_from_args: filter_from_args, query: query)
@@ -69,28 +69,25 @@ module ElasticGraph
         #
         # - The field paths we are filtering on.
         # - The field paths that are sourced from `SELF_RELATIONSHIP_NAME`.
-        def determine_paths_to_check(filter, index_fields_by_path, parent_path: "")
-          filter.compact.flat_map do |field_name, value|
-            path = parent_path + field_name
-
-            if (index_field = index_fields_by_path[path])
-              # We've recursed down to a field path. We want that path to be returned if the
-              # field is sourced from SELF_RELATIONSHIP_NAME.
-              (index_field.source == SELF_RELATIONSHIP_NAME) ? [path] : []
-            elsif field_name == schema_element_names.any_of
-              # `any_of` represents an OR and the value will be an array, so we have to flat map over it.
-              value.flat_map do |sub_filter|
+        def determine_paths_to_check(expression, index_fields_by_path, parent_path: nil)
+          return [] unless expression.is_a?(::Hash)
+
+          expression.compact.flat_map do |field_or_op, sub_expression|
+            if filter_node_interpreter.identify_node_type(field_or_op, sub_expression) == :sub_field
+              path = parent_path ? "#{parent_path}.#{field_or_op}" : field_or_op
+              if (index_field = index_fields_by_path[path])
+                # We've recursed down to a leaf field path. We want that path to be returned if the
+                # field is sourced from SELF_RELATIONSHIP_NAME.
+                (index_field.source == SELF_RELATIONSHIP_NAME) ? [path] : []
+              else
+                determine_paths_to_check(sub_expression, index_fields_by_path, parent_path: path)
+              end
+            elsif sub_expression.is_a?(::Array)
+              sub_expression.flat_map do |sub_filter|
                 determine_paths_to_check(sub_filter, index_fields_by_path, parent_path: parent_path)
               end
-            elsif field_name == schema_element_names.not
-              # While `not` represents negation, we don't have to negate anything here because the negation
-              # is handled later (when we use `filter_value_set_extractor`). Here we are just determining the
-              # paths to check. We want to recurse without adding `not` to the `parent_path` since it's not
-              # part of the field path.
-              determine_paths_to_check(value, index_fields_by_path, parent_path: parent_path)
             else
-              # ...otherwise, `field_name` is a parent field and we need to recurse down through the children.
-              determine_paths_to_check(value, index_fields_by_path, parent_path: "#{path}.")
+              determine_paths_to_check(sub_expression, index_fields_by_path, parent_path: parent_path)
             end
           end
         end

data/lib/elastic_graph/graphql.rb

@@ -181,7 +181,11 @@ module ElasticGraph
 
         [
           GraphQL::QueryAdapter::Pagination.new(schema_element_names: schema_element_names),
-          GraphQL::QueryAdapter::Filters.new(schema_element_names: schema_element_names, filter_args_translator: filter_args_translator),
+          GraphQL::QueryAdapter::Filters.new(
+            schema_element_names: schema_element_names,
+            filter_args_translator: filter_args_translator,
+            filter_node_interpreter: filter_node_interpreter
+          ),
           GraphQL::QueryAdapter::Sort.new(order_by_arg_name: schema_element_names.order_by),
           Aggregation::QueryAdapter.new(
             schema: schema,
@@ -199,7 +203,15 @@ module ElasticGraph
     def filter_interpreter
       @filter_interpreter ||= begin
         require "elastic_graph/graphql/filtering/filter_interpreter"
-        Filtering::FilterInterpreter.new(runtime_metadata: runtime_metadata, logger: logger)
+        Filtering::FilterInterpreter.new(filter_node_interpreter: filter_node_interpreter, logger: logger)
+      end
+    end
+
+    # @private
+    def filter_node_interpreter
+      @filter_node_interpreter ||= begin
+        require "elastic_graph/graphql/filtering/filter_node_interpreter"
+        Filtering::FilterNodeInterpreter.new(runtime_metadata: runtime_metadata)
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elasticgraph-graphql
 version: !ruby/object:Gem::Version
-  version: 0.18.0.2
+  version: 0.18.0.4
 platform: ruby
 authors:
 - Myron Marston
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-09-05 00:00:00.000000000 Z
+date: 2024-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop-factory_bot
@@ -266,28 +266,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.2
+        version: 0.18.0.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.2
+        version: 0.18.0.4
 - !ruby/object:Gem::Dependency
   name: elasticgraph-schema_artifacts
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.2
+        version: 0.18.0.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.2
+        version: 0.18.0.4
 - !ruby/object:Gem::Dependency
   name: graphql
   requirement: !ruby/object:Gem::Requirement
@@ -308,70 +308,70 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.2
+        version: 0.18.0.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.2
+        version: 0.18.0.4
 - !ruby/object:Gem::Dependency
   name: elasticgraph-elasticsearch
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.2
+        version: 0.18.0.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.2
+        version: 0.18.0.4
 - !ruby/object:Gem::Dependency
   name: elasticgraph-opensearch
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.2
+        version: 0.18.0.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.2
+        version: 0.18.0.4
 - !ruby/object:Gem::Dependency
   name: elasticgraph-indexer
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.2
+        version: 0.18.0.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.2
+        version: 0.18.0.4
 - !ruby/object:Gem::Dependency
   name: elasticgraph-schema_definition
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.2
+        version: 0.18.0.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.2
+        version: 0.18.0.4
 description: 
 email:
 - myron@squareup.com
@@ -418,6 +418,7 @@ files:
 - lib/elastic_graph/graphql/filtering/field_path.rb
 - lib/elastic_graph/graphql/filtering/filter_args_translator.rb
 - lib/elastic_graph/graphql/filtering/filter_interpreter.rb
+- lib/elastic_graph/graphql/filtering/filter_node_interpreter.rb
 - 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