elasticgraph-graphql 0.18.0.3 → 0.18.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a520631b7964685b34d5089eb26772a9754e955ac53ce7706d9a844a06c281c3
-  data.tar.gz: 02e9144c3197c43a208c100fcc3a340301caf041fd12783b4cd08f37d3f28645
+  metadata.gz: 53e5c759fafb5fe181ae65912c42b21d6d6dbe8cbd3558962cb5a56bc94944b6
+  data.tar.gz: 862a18dd839b8ee841b91430eb7188612c5483c5701930cf23cfbb22ce44e876
 SHA512:
-  metadata.gz: 9540df01b507f1b3bcdae32699c3cf830b900507953f70504515afd0c5c7bf7160fb13b78750a272da823e81795d247c56c47ba7bff0d977193dad744ed7e6ba
-  data.tar.gz: 68e4cee0d55d42693641901bafc0e811a7f596b831d438ce9882ae259c0006ac12580726785c9fa2918e1abb0cb5b804da088f7bef4f83a4220958b07b73fbec
+  metadata.gz: 4739bc5c2978a75528777b58073ba9e606a5964ff1adcfbb1b19c77eb43e29c5bb19e5aa137d2b530bd2937ca5499538149959b23cf55a7912f9b04b50809e3f
+  data.tar.gz: fb6b7226810f2f58bd7aedca80a9e1be097ffbbc8dbb5532805f9d98392006e2c4f0db7344c64250c3bd6adcdb917972e230324cc876c0639bba3a40d0601067

data/lib/elastic_graph/graphql/aggregation/field_path_encoder.rb

@@ -6,7 +6,7 @@
 #
 # frozen_string_literal: true
 
-require "elastic_graph/error"
+require "elastic_graph/errors"
 
 module ElasticGraph
   class GraphQL
@@ -38,7 +38,7 @@ module ElasticGraph
 
         private_class_method def self.verify_delimiters(str)
           if str.to_s.include?(DELIMITER)
-            raise InvalidArgumentValueError, %("#{str}" contains delimiter: "#{DELIMITER}")
+            raise Errors::InvalidArgumentValueError, %("#{str}" contains delimiter: "#{DELIMITER}")
           end
         end
       end

data/lib/elastic_graph/graphql/aggregation/key.rb

@@ -6,7 +6,7 @@
 #
 # frozen_string_literal: true
 
-require "elastic_graph/error"
+require "elastic_graph/errors"
 require "elastic_graph/graphql/aggregation/field_path_encoder"
 
 module ElasticGraph
@@ -77,7 +77,7 @@ module ElasticGraph
         def self.verify_no_delimiter_in(*parts)
           parts.each do |part|
             if part.to_s.include?(DELIMITER)
-              raise InvalidArgumentValueError, %("#{part}" contains delimiter: "#{DELIMITER}")
+              raise Errors::InvalidArgumentValueError, %("#{part}" contains delimiter: "#{DELIMITER}")
             end
           end
         end

data/lib/elastic_graph/graphql/config.rb

@@ -6,7 +6,7 @@
 #
 # frozen_string_literal: true
 
-require "elastic_graph/error"
+require "elastic_graph/errors"
 require "elastic_graph/graphql/client"
 require "elastic_graph/schema_artifacts/runtime_metadata/extension_loader"
 
@@ -33,14 +33,14 @@ module ElasticGraph
         extra_keys = parsed_yaml.keys - EXPECTED_KEYS
 
         unless extra_keys.empty?
-          raise ConfigError, "Unknown `graphql` config settings: #{extra_keys.join(", ")}"
+          raise Errors::ConfigError, "Unknown `graphql` config settings: #{extra_keys.join(", ")}"
         end
 
         extension_loader = SchemaArtifacts::RuntimeMetadata::ExtensionLoader.new(::Module.new)
         extension_mods = parsed_yaml.fetch("extension_modules", []).map do |mod_hash|
           extension_loader.load(mod_hash.fetch("extension_name"), from: mod_hash.fetch("require_path"), config: {}).extension_class.tap do |mod|
             unless mod.instance_of?(::Module)
-              raise ConfigError, "`#{mod_hash.fetch("extension_name")}` is not a module, but all application extension modules must be modules."
+              raise Errors::ConfigError, "`#{mod_hash.fetch("extension_name")}` is not a module, but all application extension modules must be modules."
             end
           end
         end

data/lib/elastic_graph/graphql/datastore_query/document_paginator.rb

@@ -6,7 +6,7 @@
 #
 # frozen_string_literal: true
 
-require "elastic_graph/error"
+require "elastic_graph/errors"
 require "graphql"
 
 module ElasticGraph

data/lib/elastic_graph/graphql/datastore_query/paginator.rb

@@ -6,7 +6,7 @@
 #
 # frozen_string_literal: true
 
-require "elastic_graph/error"
+require "elastic_graph/errors"
 require "elastic_graph/support/memoizable_data"
 
 module ElasticGraph

data/lib/elastic_graph/graphql/datastore_query.rb

@@ -6,7 +6,7 @@
 #
 # frozen_string_literal: true
 
-require "elastic_graph/error"
+require "elastic_graph/errors"
 require "elastic_graph/graphql/aggregation/query"
 require "elastic_graph/graphql/aggregation/query_optimizer"
 require "elastic_graph/graphql/decoded_cursor"
@@ -65,7 +65,7 @@ module ElasticGraph
         )
 
         if search_index_definitions.empty?
-          raise SearchFailedError, "Query is invalid, since it contains no `search_index_definitions`."
+          raise Errors::SearchFailedError, "Query is invalid, since it contains no `search_index_definitions`."
         end
       end
     }
@@ -121,7 +121,7 @@ module ElasticGraph
             missing_queries = expected_queries - actual_queries
             extra_queries = actual_queries - expected_queries
 
-            raise SearchFailedError, "The `responses_hash` does not have the expected set of queries as keys. " \
+            raise Errors::SearchFailedError, "The `responses_hash` does not have the expected set of queries as keys. " \
               "This can cause problems for the `GraphQL::Dataloader` and suggests a bug in the logic that should be fixed.\n\n" \
               "Missing queries (#{missing_queries.size}):\n#{missing_queries.map(&:inspect).join("\n")}.\n\n" \
               "Extra queries (#{extra_queries.size}): #{extra_queries.map(&:inspect).join("\n")}"
@@ -133,7 +133,7 @@ module ElasticGraph
       # Both query objects are left unchanged.
       def merge(other_query)
         if search_index_definitions != other_query.search_index_definitions
-          raise ElasticGraph::InvalidMergeError, "`search_index_definitions` conflict while merging between " \
+          raise ElasticGraph::Errors::InvalidMergeError, "`search_index_definitions` conflict while merging between " \
             "#{search_index_definitions} and #{other_query.search_index_definitions}"
         end
 
@@ -177,11 +177,11 @@ module ElasticGraph
       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 ConfigError.
+      # Unless exactly 1 cluster name is found, this method raises a Errors::ConfigError.
       def cluster_name
         cluster_name = search_index_definitions.map(&:cluster_to_query).uniq
         return cluster_name.first if cluster_name.size == 1
-        raise ConfigError, "Found different datastore clusters (#{cluster_name}) to query " \
+        raise Errors::ConfigError, "Found different datastore clusters (#{cluster_name}) to query " \
           "for query targeting indices: #{search_index_definitions}"
       end
 

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

@@ -6,7 +6,7 @@
 #
 # frozen_string_literal: true
 
-require "elastic_graph/error"
+require "elastic_graph/errors"
 require "elastic_graph/graphql/decoded_cursor"
 require "elastic_graph/graphql/datastore_response/document"
 require "forwardable"
@@ -66,7 +66,7 @@ module ElasticGraph
         end
 
         def total_document_count
-          super || raise(CountUnavailableError, "#{__method__} is unavailable; set `query.total_document_count_needed = true` to make it available")
+          super || raise(Errors::CountUnavailableError, "#{__method__} is unavailable; set `query.total_document_count_needed = true` to make it available")
         end
 
         def to_s

data/lib/elastic_graph/graphql/datastore_search_router.rb

@@ -7,7 +7,7 @@
 # frozen_string_literal: true
 
 require "elastic_graph/constants"
-require "elastic_graph/error"
+require "elastic_graph/errors"
 require "elastic_graph/graphql/datastore_response/search_response"
 require "elastic_graph/graphql/query_details_tracker"
 require "elastic_graph/support/threading"
@@ -108,7 +108,7 @@ module ElasticGraph
 
         (min_query_deadline - @monotonic_clock.now_in_ms).tap do |timeout|
           if timeout <= 0
-            raise RequestExceededDeadlineError, "It is already #{timeout.abs} ms past the search deadline."
+            raise Errors::RequestExceededDeadlineError, "It is already #{timeout.abs} ms past the search deadline."
           end
         end
       end
@@ -127,7 +127,7 @@ module ElasticGraph
           ERROR
         end.join("\n\n")
 
-        raise SearchFailedError, "Got #{failures.size} search failure(s):\n\n#{formatted_failures}"
+        raise Errors::SearchFailedError, "Got #{failures.size} search failure(s):\n\n#{formatted_failures}"
       end
 
       # Examine successful query responses and log any shard failure they encounter

data/lib/elastic_graph/graphql/decoded_cursor.rb

@@ -8,7 +8,7 @@
 
 require "base64"
 require "elastic_graph/constants"
-require "elastic_graph/error"
+require "elastic_graph/errors"
 require "elastic_graph/support/memoizable_data"
 require "json"
 
@@ -39,17 +39,17 @@ module ElasticGraph
       # Tries to decode the given string cursor, returning `nil` if it is invalid.
       def self.try_decode(string)
         decode!(string)
-      rescue InvalidCursorError
+      rescue Errors::InvalidCursorError
         nil
       end
 
-      # Tries to decode the given string cursor, raising an `InvalidCursorError` if it's invalid.
+      # Tries to decode the given string cursor, raising an `Errors::InvalidCursorError` if it's invalid.
       def self.decode!(string)
         return SINGLETON if string == SINGLETON_CURSOR
         json = ::Base64.urlsafe_decode64(string)
         new(::JSON.parse(json))
       rescue ::ArgumentError, ::JSON::ParserError
-        raise InvalidCursorError, "`#{string}` is an invalid cursor."
+        raise Errors::InvalidCursorError, "`#{string}` is an invalid cursor."
       end
 
       # Encodes the cursor to a string using JSON and Base64 encoding.
@@ -79,7 +79,7 @@ module ElasticGraph
         def self.from_sort_list(sort_list)
           sort_fields = sort_list.map do |hash|
             if hash.values.any? { |v| !v.is_a?(::Hash) } || hash.values.flat_map(&:keys) != ["order"]
-              raise InvalidSortFieldsError,
+              raise Errors::InvalidSortFieldsError,
                 "Given `sort_list` contained an invalid entry. Each must be a flat hash with one entry. Got: #{sort_list.inspect}"
             end
 
@@ -89,7 +89,7 @@ module ElasticGraph
           end
 
           if sort_fields.uniq.size < sort_fields.size
-            raise InvalidSortFieldsError,
+            raise Errors::InvalidSortFieldsError,
               "Given `sort_list` contains a duplicate field, which the CursorEncoder cannot handler. " \
               "The caller is responsible for de-duplicating the sort list fist. Got: #{sort_list.inspect}"
           end
@@ -99,7 +99,7 @@ module ElasticGraph
 
         def build(sort_values)
           unless sort_values.size == sort_fields.size
-            raise CursorEncodingError,
+            raise Errors::CursorEncodingError,
               "size of sort values (#{sort_values.inspect}) does not match the " \
               "size of sort fields (#{sort_fields.inspect})"
           end

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
@@ -230,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
 
@@ -369,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

@@ -62,7 +62,7 @@ module ElasticGraph
 
           HTTPResponse.json(200, result.to_h)
         end
-      rescue RequestExceededDeadlineError
+      rescue Errors::RequestExceededDeadlineError
         HTTPResponse.error(504, "Search exceeded requested timeout.")
       end
 
@@ -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/query_executor.rb

@@ -29,7 +29,7 @@ module ElasticGraph
       # Executes the given `query_string` using the provided `variables`.
       #
       # `timeout_in_ms` can be provided to limit how long the query runs for. If the timeout
-      # is exceeded, `RequestExceededDeadlineError` will be raised. Note that `timeout_in_ms`
+      # is exceeded, `Errors::RequestExceededDeadlineError` will be raised. Note that `timeout_in_ms`
       # does not provide an absolute guarantee that the query will take no longer than the
       # provided value; it is only used to halt datastore queries. In process computation
       # can make the total query time exceeded the specified timeout.

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

@@ -6,7 +6,7 @@
 #
 # frozen_string_literal: true
 
-require "elastic_graph/error"
+require "elastic_graph/errors"
 require "elastic_graph/support/memoizable_data"
 
 module ElasticGraph
@@ -48,7 +48,7 @@ module ElasticGraph
 
         def canonical_name_for(name, element_type)
           schema_element_names.canonical_name_for(name) ||
-            raise(SchemaError, "#{element_type} `#{name}` is not a defined schema element")
+            raise(Errors::SchemaError, "#{element_type} `#{name}` is not a defined schema element")
         end
       end
     end

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

@@ -58,7 +58,7 @@ module ElasticGraph
                 # extra memory allocation and GC for the hash.
                 arg_defn = arg_defns.find do |a|
                   a.keyword == key
-                end || raise(SchemaError, "Cannot find an argument definition for #{key.inspect} on `#{args_owner.name}`")
+                end || raise(Errors::SchemaError, "Cannot find an argument definition for #{key.inspect} on `#{args_owner.name}`")
 
                 next_owner = arg_defn.type.unwrap
                 accumulator[arg_defn.name] = to_schema_form(value, next_owner)

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

@@ -6,7 +6,7 @@
 #
 # frozen_string_literal: true
 
-require "elastic_graph/error"
+require "elastic_graph/errors"
 
 module ElasticGraph
   class GraphQL
@@ -15,7 +15,7 @@ module ElasticGraph
       class EnumValue < ::Data.define(:name, :type, :runtime_metadata)
         def sort_clauses
           sort_clause = runtime_metadata&.sort_field&.then { |sf| {sf.field_path => {"order" => sf.direction.to_s}} } ||
-            raise(SchemaError, "Runtime metadata provides no `sort_field` for #{type.name}.#{name} enum value.")
+            raise(Errors::SchemaError, "Runtime metadata provides no `sort_field` for #{type.name}.#{name} enum value.")
 
           [sort_clause]
         end

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

@@ -6,7 +6,7 @@
 #
 # frozen_string_literal: true
 
-require "elastic_graph/error"
+require "elastic_graph/errors"
 require "elastic_graph/graphql/schema/relation_join"
 require "elastic_graph/graphql/schema/arguments"
 
@@ -126,7 +126,7 @@ module ElasticGraph
         def sort_argument_type
           @sort_argument_type ||= begin
             graphql_argument = @graphql_field.arguments.fetch(schema_element_names.order_by) do
-              raise SchemaError, "`#{schema_element_names.order_by}` argument not defined for field `#{parent_type.name}.#{name}`."
+              raise Errors::SchemaError, "`#{schema_element_names.order_by}` argument not defined for field `#{parent_type.name}.#{name}`."
             end
             @schema.type_from(graphql_argument.type.unwrap)
           end

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

@@ -7,7 +7,7 @@
 # frozen_string_literal: true
 
 require "elastic_graph/datastore_core/index_definition"
-require "elastic_graph/error"
+require "elastic_graph/errors"
 require "elastic_graph/graphql/schema/field"
 require "elastic_graph/graphql/schema/enum_value"
 require "forwardable"
@@ -118,7 +118,7 @@ module ElasticGraph
         rescue KeyError => e
           msg = "No field named #{field_name} (on type #{name}) could be found"
           msg += "; Possible alternatives: [#{e.corrections.join(", ").delete('"')}]." if e.corrections.any?
-          raise NotFoundError, msg
+          raise Errors::NotFoundError, msg
         end
 
         def enum_value_named(enum_value_name)
@@ -233,7 +233,7 @@ module ElasticGraph
         rescue KeyError => e
           msg = "No enum value named #{enum_value_name} (on type #{name}) could be found"
           msg += "; Possible alternatives: [#{e.corrections.join(", ").delete('"')}]." if e.corrections.any?
-          raise NotFoundError, msg
+          raise Errors::NotFoundError, msg
         end
 
         def build_fields_by_name_hash(schema, graphql_type)

data/lib/elastic_graph/graphql/schema.rb

@@ -10,7 +10,7 @@ require "digest/md5"
 require "forwardable"
 require "graphql"
 require "elastic_graph/constants"
-require "elastic_graph/error"
+require "elastic_graph/errors"
 require "elastic_graph/graphql/monkey_patches/schema_field"
 require "elastic_graph/graphql/monkey_patches/schema_object"
 require "elastic_graph/graphql/schema/field"
@@ -88,7 +88,7 @@ module ElasticGraph
           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."
           else
-            raise NotFoundError, "The index definition `#{index_definition_name}` does not appear to exist. Is it misspelled?"
+            raise Errors::NotFoundError, "The index definition `#{index_definition_name}` does not appear to exist. Is it misspelled?"
           end
         end
       end
@@ -133,7 +133,7 @@ module ElasticGraph
       rescue KeyError => e
         msg = "No type named #{type_name} could be found"
         msg += "; Possible alternatives: [#{e.corrections.join(", ").delete('"')}]." if e.corrections.any?
-        raise NotFoundError, msg
+        raise Errors::NotFoundError, msg
       end
 
       def resolver
@@ -152,7 +152,7 @@ module ElasticGraph
         @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 SchemaError, "DatastoreCore::IndexDefinition #{index_def.name} is used multiple times: #{type} vs #{hash[index_def.name]}"
+              raise Errors::SchemaError, "DatastoreCore::IndexDefinition #{index_def.name} is used multiple times: #{type} vs #{hash[index_def.name]}"
             end
 
             hash[index_def.name] = type

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,16 @@
 --- !ruby/object:Gem::Specification
 name: elasticgraph-graphql
 version: !ruby/object:Gem::Version
-  version: 0.18.0.3
+  version: 0.18.0.5
 platform: ruby
 authors:
 - Myron Marston
+- Ben VandenBos
+- Square Engineering
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-09-05 00:00:00.000000000 Z
+date: 2024-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop-factory_bot
@@ -266,28 +268,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.3
+        version: 0.18.0.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.3
+        version: 0.18.0.5
 - !ruby/object:Gem::Dependency
   name: elasticgraph-schema_artifacts
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.3
+        version: 0.18.0.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.3
+        version: 0.18.0.5
 - !ruby/object:Gem::Dependency
   name: graphql
   requirement: !ruby/object:Gem::Requirement
@@ -308,70 +310,70 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.3
+        version: 0.18.0.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.3
+        version: 0.18.0.5
 - !ruby/object:Gem::Dependency
   name: elasticgraph-elasticsearch
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.3
+        version: 0.18.0.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.3
+        version: 0.18.0.5
 - !ruby/object:Gem::Dependency
   name: elasticgraph-opensearch
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.3
+        version: 0.18.0.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.3
+        version: 0.18.0.5
 - !ruby/object:Gem::Dependency
   name: elasticgraph-indexer
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.3
+        version: 0.18.0.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.3
+        version: 0.18.0.5
 - !ruby/object:Gem::Dependency
   name: elasticgraph-schema_definition
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.3
+        version: 0.18.0.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.3
+        version: 0.18.0.5
 description: 
 email:
 - myron@squareup.com
@@ -418,6 +420,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