elasticgraph-graphql 0.19.3.0 → 1.0.0.rc2

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

@@ -15,31 +15,30 @@ module ElasticGraph
     class QueryAdapter
       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)
-          filters = [filter_from_args, automatic_filter].compact
-          return query if filters.empty?
+          client_filter = filter_args_translator.translate_filter_args(field: field, args: args)
+          internal_filter = build_automatic_filter(client_filter: client_filter, query: query)
+          return query if client_filter.nil? && internal_filter.nil?
 
-          query.merge_with(filters: filters)
+          query.merge_with(client_filters: [client_filter].compact, internal_filters: [internal_filter].compact)
         end
 
         private
 
-        def build_automatic_filter(filter_from_args:, query:)
+        def build_automatic_filter(client_filter:, query:)
           # If an incomplete document could be hit by a search with our filters against any of the
           # index definitions, we must add a filter that will exclude incomplete documents.
           exclude_incomplete_docs_filter if query
             .search_index_definitions
-            .any? { |index_def| search_could_hit_incomplete_docs?(index_def, filter_from_args || {}) }
+            .any? { |index_def| search_could_hit_incomplete_docs?(index_def, client_filter || {}) }
         end
 
         def exclude_incomplete_docs_filter
           {"__sources" => {schema_element_names.equal_to_any_of => [SELF_RELATIONSHIP_NAME]}}
         end
 
-        # Indicates if a search against the given `index_def` using the given `filter_from_args`
+        # Indicates if a search against the given `index_def` using the given `client_filter`
         # could hit an incomplete document.
-        def search_could_hit_incomplete_docs?(index_def, filter_from_args)
+        def search_could_hit_incomplete_docs?(index_def, client_filter)
           # If the index definition doesn't allow any searches to hit incomplete documents, we
           # can immediately return `false` without checking the filters.
           return false unless index_def.searches_could_hit_incomplete_docs?
@@ -53,7 +52,7 @@ module ElasticGraph
           #
           # Here we determine what field paths we need to check (e.g. only those field paths that are against
           # self-sourced fields).
-          paths_to_check = determine_paths_to_check(filter_from_args, index_def.fields_by_path)
+          paths_to_check = determine_paths_to_check(client_filter, index_def.fields_by_path)
 
           # If we have no paths to check, then our filters don't exclude incomplete documents and we must return `true`.
           return true if paths_to_check.empty?
@@ -61,7 +60,7 @@ module ElasticGraph
           # Finally, we look over each path. If all our filters allow the search to match documents that have `nil`
           # at that path, then the search can hit incomplete documents. But if even one path excludes documents
           # that have a `null` value for the field, we can safely return `false` for a more efficient query.
-          paths_to_check.all? { |path| can_match_nil_values_at?(path, filter_from_args) }
+          paths_to_check.all? { |path| can_match_nil_values_at?(path, client_filter) }
         end
 
         # Figures out which field paths we need to check to see if a filter on it could match an incomplete document.

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

@@ -50,9 +50,15 @@ module ElasticGraph
 
           attributes =
             if field.type.relay_connection?
+              highlights = lookahead
+                .selection(@schema.element_names.edges)
+                .selection(@schema.element_names.highlights)
+
               {
                 individual_docs_needed: pagination_fields_need_individual_docs?(lookahead),
-                requested_fields: requested_fields_under(relay_connection_node_from(lookahead), index_field_paths)
+                requested_fields: requested_fields_under(relay_connection_node_from(lookahead), index_field_paths),
+                request_all_highlights: requesting_all_highlights?(lookahead),
+                requested_highlights: requested_fields_under(highlights, index_field_paths)
               }
             else
               {
@@ -142,6 +148,15 @@ module ElasticGraph
           lookahead.selects?(@schema.element_names.total_edge_count)
         end
 
+        def requesting_all_highlights?(lookahead)
+          all_highlights =
+            lookahead
+              .selection(@schema.element_names.edges)
+              .selection(@schema.element_names.all_highlights)
+
+          all_highlights.selects?(@schema.element_names.path) || all_highlights.selects?(@schema.element_names.snippets)
+        end
+
         def graphql_dynamic_field?(node)
           # As per https://spec.graphql.org/October2021/#sec-Objects,
           # > All fields defined within an Object type must not have a name which begins with "__"

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

@@ -16,7 +16,6 @@ module ElasticGraph
       # Responsible for fetching a single field value from a document.
       class GetRecordFieldValue
         def initialize(elasticgraph_graphql:, config:)
-          @schema_element_names = elasticgraph_graphql.runtime_metadata.schema_element_names
         end
 
         def resolve(field:, object:, args:, context:)
@@ -32,7 +31,7 @@ module ElasticGraph
           value = [] if value.nil? && field.type.list?
 
           if field.type.relay_connection?
-            RelayConnection::ArrayAdapter.build(value, args, @schema_element_names, context)
+            RelayConnection::ArrayAdapter.build(value, args, context)
           else
             value
           end

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

@@ -23,7 +23,6 @@ module ElasticGraph
           @schema_element_names = elasticgraph_graphql.runtime_metadata.schema_element_names
           @logger = elasticgraph_graphql.logger
           @monotonic_clock = elasticgraph_graphql.monotonic_clock
-          @resolver_mode = elasticgraph_graphql.config.nested_relationship_resolver_mode
         end
 
         def resolve(field:, object:, args:, context:, lookahead:)
@@ -41,8 +40,7 @@ module ElasticGraph
                 NestedRelationshipsSource.execute_one(
                   Array(id_or_ids).to_set,
                   query:, join:, context:,
-                  monotonic_clock: @monotonic_clock,
-                  mode: @resolver_mode
+                  monotonic_clock: @monotonic_clock
                 )
 
               join.normalize_documents(initial_response) do |problem|

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

@@ -32,7 +32,7 @@ module ElasticGraph
       #
       # This optimization, when we can apply it, results in much less load on the datastore. In addition, it also helps to reduce
       # the amount of overhead imposed by ElasticGraph. Profiling has shown that significant overhead is incurred when we repeatedly
-      # merge filters into a query (e.g. `query.merge_with(filters: [{id: {equal_to_any_of: [part.manufacturer_id]}}])` 10 times to
+      # merge filters into a query (e.g. `query.merge_with(internal_filters: [{id: {equal_to_any_of: [part.manufacturer_id]}}])` 10 times to
       # produce 10 different queries). This optimization also avoids that overhead.
       #
       # Note: while the comments discuss the examples in terms of _parent objects_, in the implementation, we deal with id sets.
@@ -60,7 +60,7 @@ module ElasticGraph
         # isn't particularly expensive, compared to needing to re-run an extra query.
         EXTRA_SIZE_MULTIPLIER = 4
 
-        def initialize(query:, join:, context:, monotonic_clock:, mode:)
+        def initialize(query:, join:, context:, monotonic_clock:)
           @query = query
           @join = join
           @filter_id_field_name_path = @join.filter_id_field_name.split(".")
@@ -69,24 +69,15 @@ module ElasticGraph
           @schema_element_names = elastic_graph_schema.element_names
           @logger = elastic_graph_schema.logger
           @monotonic_clock = monotonic_clock
-          @mode = mode
         end
 
         def fetch(id_sets)
           return fetch_original(id_sets) unless can_merge_filters?
-
-          case @mode
-          when :original
-            fetch_original(id_sets)
-          when :comparison
-            fetch_comparison(id_sets)
-          else
-            fetch_optimized(id_sets)
-          end
+          fetch_optimized(id_sets)
         end
 
-        def self.execute_one(ids, query:, join:, context:, monotonic_clock:, mode:)
-          context.dataloader.with(self, query:, join:, context:, monotonic_clock:, mode:).load(ids)
+        def self.execute_one(ids, query:, join:, context:, monotonic_clock:)
+          context.dataloader.with(self, query:, join:, context:, monotonic_clock:).load(ids)
         end
 
         private
@@ -116,52 +107,6 @@ module ElasticGraph
           fetch_via_separate_queries(id_sets, requested_fields: requested_fields)
         end
 
-        def fetch_comparison(id_sets)
-          # Note: we'd ideally run both versions of the logic in parallel, but our attempts to do that resulted in errors
-          # because of the fiber context in which dataloaders run.
-          original_duration_ms, original_results = time_duration do
-            # In the `fetch_optimized` implementation, we request this extra field. We don't need it for
-            # the original implementation (so `fetch_original` doesn't also request that field...) but for
-            # the purposes of comparison we need to request it so that the document payloads will have the
-            # same fields.
-            #
-            # Note: we don't add the requested field if we have only a single id set, in order to align with
-            # the short-circuiting logic in `fetch_via_single_query_with_merged_filters`. Otherwise, any time
-            # we have a single id set we always get reported differences which are not actually real!
-            requested_fields = (id_sets.size > 1) ? [@join.filter_id_field_name] : [] # : ::Array[::String]
-            fetch_original(id_sets, requested_fields: requested_fields)
-          end
-
-          optimized_duration_ms, optimized_results = time_duration do
-            fetch_optimized(id_sets)
-          end
-
-          # To see if we got the same results we only look at the documents, because we expect differences outside
-          # of the documents--for example, the `SearchResponse#metadata` will report different `took` values.
-          got_same_results = original_results.map(&:documents) == optimized_results.map(&:documents)
-          message = {
-            "message_type" => "NestedRelationshipsComparisonResults",
-            "field" => @join.field.description,
-            "original_duration_ms" => original_duration_ms,
-            "optimized_duration_ms" => optimized_duration_ms,
-            "optimized_faster" => (optimized_duration_ms < original_duration_ms),
-            "id_set_count" => id_sets.size,
-            "total_id_count" => id_sets.reduce(:union).size,
-            "got_same_results" => got_same_results
-          }
-
-          if got_same_results
-            @logger.info(message)
-          else
-            @logger.error(message.merge({
-              "original_documents" => loggable_results(original_results),
-              "optimized_documents" => loggable_results(optimized_results)
-            }))
-          end
-
-          original_results
-        end
-
         # For "simple", document-based queries, we can safely merge filters. However, this cannot be done safely when the response
         # cannot safely be "pulled part" into the bits that apply to a particular set of ids for a parent object. Specifically:
         #
@@ -227,7 +172,7 @@ module ElasticGraph
 
           # First, we build a combined query with filters that account for all ids we are filtering on from all `id_sets`.
           filtered_query = @query.merge_with(
-            filters: filters_for(id_sets.reduce(:union)),
+            internal_filters: filters_for(id_sets.reduce(:union)),
             requested_fields: [@join.filter_id_field_name],
             # We need to request a larger size than `@query` originally had. If the original size was `10` and we have
             # 5 sets of ids, then, at a minimum, we need to request 50 results (10 results for each id set).
@@ -271,7 +216,7 @@ module ElasticGraph
 
         def fetch_via_separate_queries(id_sets, requested_fields: [])
           queries = id_sets.map do |ids|
-            @query.merge_with(filters: filters_for(ids), requested_fields: requested_fields)
+            @query.merge_with(internal_filters: filters_for(ids), requested_fields: requested_fields)
           end
 
           results = QuerySource.execute_many(queries, for_context: @context)
@@ -307,18 +252,6 @@ module ElasticGraph
           stop_time = @monotonic_clock.now_in_ms
           [stop_time - start_time, result]
         end
-
-        # Converts the given list of responses into a format we can safely log when we are logging
-        # response differences. We include the `id` (to identify the document) and the `hash` (so
-        # we can tell if the payload of a document differed, without logging the contents of that
-        # payload).
-        def loggable_results(responses)
-          responses.map do |response|
-            response.documents.map do |doc|
-              "#{doc.id} (hash: #{doc.hash})"
-            end
-          end
-        end
       end
     end
   end

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

@@ -27,7 +27,6 @@ module ElasticGraph
 
         def fetch(queries)
           responses_by_query = @datastore_router.msearch(queries, query_tracker: @query_tracker)
-          @query_tracker.record_datastore_queries_for_single_request(queries)
           queries.map { |q| responses_by_query.fetch(q) }
         end
 

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

@@ -17,15 +17,18 @@ module ElasticGraph
         # here we just adapt it to the ElasticGraph internal resolver interface.
         class ArrayAdapter < ResolvableValue.new(:graphql_impl, :total_edge_count)
           # `ResolvableValue.new` provides the following methods:
-          # @dynamic initialize, graphql_impl, total_edge_count, schema_element_names
+          # @dynamic initialize, graphql_impl, total_edge_count, schema
 
           # `def_delegators` provides the following methods:
           # @dynamic start_cursor, end_cursor, has_next_page, has_previous_page
           extend Forwardable
           def_delegators :graphql_impl, :start_cursor, :end_cursor, :has_next_page, :has_previous_page
 
-          def self.build(nodes, args, schema_element_names, context)
+          def self.build(nodes, args, context)
+            schema = context.fetch(:elastic_graph_schema)
+            schema_element_names = schema.element_names
             nodes ||= [] # : ::Array[untyped]
+
             # ElasticGraph supports any schema elements (like a `first` argument) being renamed,
             # but `GraphQL::Relay::ArrayConnection` would not understand a renamed argument.
             # Here we map the args back to the canonical relay args so `ArrayConnection` can
@@ -40,7 +43,7 @@ module ElasticGraph
             }.compact
 
             graphql_impl = ::GraphQL::Pagination::ArrayConnection.new(nodes, context: context, **relay_args)
-            new(schema_element_names, graphql_impl, nodes.size)
+            new(schema, graphql_impl, nodes.size)
           end
 
           def page_info
@@ -49,7 +52,7 @@ module ElasticGraph
 
           def edges
             @edges ||= graphql_impl.nodes.map do |node|
-              Edge.new(schema_element_names, graphql_impl, node)
+              Edge.new(schema, graphql_impl, node)
             end
           end
 
@@ -60,7 +63,7 @@ module ElasticGraph
           # Simple edge implementation for a node object.
           class Edge < ResolvableValue.new(:graphql_impl, :node)
             # `ResolvableValue.new` provides the following methods:
-            # @dynamic initialize, graphql_impl, schema_element_names, node
+            # @dynamic initialize, graphql_impl, schema, node
 
             def cursor
               graphql_impl.cursor_for(node)

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

@@ -21,13 +21,15 @@ module ElasticGraph
           # Lambda that is used to convert a node to a sort value during truncation.
           :to_sort_value,
           # Gets an optional count of total edges.
-          :get_total_edge_count
+          :get_total_edge_count,
+          # The class used for edges
+          :edge_class
         )
-          # @dynamic initialize, with, schema_element_names, raw_nodes, paginator, to_sort_value, get_total_edge_count
+          # @dynamic initialize, with, schema, raw_nodes, paginator, to_sort_value, get_total_edge_count, edge_class
 
           def page_info
             @page_info ||= PageInfo.new(
-              schema_element_names: schema_element_names,
+              schema: schema,
               before_truncation_nodes: before_truncation_nodes,
               edges: edges,
               paginator: paginator
@@ -39,7 +41,7 @@ module ElasticGraph
           end
 
           def edges
-            @edges ||= nodes.map { |node| Edge.new(schema_element_names, node) }
+            @edges ||= nodes.map { |node| edge_class.new(schema, node) }
           end
 
           def nodes

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

@@ -14,14 +14,15 @@ module ElasticGraph
       module RelayConnection
         # Adapts an `DatastoreResponse::SearchResponse` to what the graphql gem expects for a relay connection.
         class SearchResponseAdapterBuilder
-          def self.build_from(schema_element_names:, search_response:, query:)
+          def self.build_from(schema:, search_response:, query:)
             document_paginator = query.document_paginator
 
             GenericAdapter.new(
-              schema_element_names: schema_element_names,
+              schema: schema,
               raw_nodes: search_response.to_a,
               paginator: document_paginator.paginator,
               get_total_edge_count: -> { search_response.total_document_count },
+              edge_class: DocumentEdge,
               to_sort_value: ->(document, decoded_cursor) do
                 (_ = document).sort.zip(decoded_cursor.sort_values.values, document_paginator.sort).map do |from_document, from_cursor, sort_clause|
                   DatastoreQuery::Paginator::SortValue.new(
@@ -34,6 +35,69 @@ module ElasticGraph
             )
           end
         end
+
+        class DocumentEdge < GenericAdapter::Edge
+          def highlights
+            @highlights ||= node.highlights.each_with_object({}) do |(path_string, snippets), highlights| # $::Hash[::String, untyped]
+              *object_fields, leaf_field = path_string.split(".")
+              leaf_hash = object_fields.reduce(highlights) { |accum, field| accum[field] ||= {} }
+              leaf_hash[leaf_field.to_s] = snippets
+            end
+          end
+
+          def all_highlights
+            @all_highlights ||= begin
+              document_type = schema.document_type_stored_in(node.index_definition_name)
+
+              node.highlights.filter_map do |path_string, snippets|
+                if (path = path_from(path_string, document_type))
+                  SearchHighlight.new(schema, path, snippets)
+                end
+              end.sort_by(&:path)
+            end
+          end
+
+          private
+
+          def path_from(path_string, document_type)
+            type = document_type
+
+            # The GraphQL field name and `name_in_index` can be different. The datastore returns path segments using
+            # the `name_in_index` but we want to return the GraphQL field name, so here we translate.
+            path_string.split(".").map do |name_in_index|
+              fields = type.unwrap_fully.fields_by_name_in_index[name_in_index] || []
+
+              # It's possible (but pretty rare) for a single `name_in_index` to map to multiple GraphQL fields.
+              # We don't really have a basis for preferring one over another so we just use the first one here.
+              field = fields.first
+
+              # It's possible (but should be *very* rare) that `name_in_index` does not map to any GraphQL fields.
+              # Here's a situation where that could happen:
+              #
+              # * The schema has an `indexing_only: true` field.
+              # * A custom query interceptor (used via `elasticgraph-query_interceptor`) merges some `client_filters` into an intercepted
+              #   query which filters on the indexing-only field.
+              #
+              # It would be more correct for the query interceptor to use `internal_filters` for that case, but in case we've
+              # run into this situation, logging a warning and hiding the highlight is the best we can do.
+              unless field
+                schema.logger.warn(
+                  "Skipping SearchHighlight for #{document_type.name} #{node.id} which contains a path (#{path_string}) " \
+                  "that does not map to any GraphQL field path."
+                )
+
+                return nil
+              end
+
+              type = field.type
+              field.name
+            end
+          end
+        end
+
+        class SearchHighlight < ResolvableValue.new(:path, :snippets)
+          # @dynamic initialize, path, snippets
+        end
       end
     end
   end

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

@@ -20,11 +20,11 @@ module ElasticGraph
         def self.maybe_wrap(search_response, field:, context:, lookahead:, query:)
           return search_response unless field.type.relay_connection?
 
-          schema_element_names = context.fetch(:elastic_graph_schema).element_names
+          schema = context.fetch(:elastic_graph_schema)
 
           unless field.type.unwrap_fully.indexed_aggregation?
             return SearchResponseAdapterBuilder.build_from(
-              schema_element_names: schema_element_names,
+              schema: schema,
               search_response: search_response,
               query: query
             )
@@ -32,7 +32,7 @@ module ElasticGraph
 
           agg_name = lookahead.ast_nodes.first&.alias || lookahead.name
           Aggregation::Resolvers::RelayConnectionBuilder.build_from_search_response(
-            schema_element_names: schema_element_names,
+            schema: schema,
             search_response: search_response,
             query: Support::HashUtil.verbose_fetch(query.aggregations, agg_name)
           )

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

@@ -17,10 +17,10 @@ module ElasticGraph
       # and also has a corresponding method definition.
       module ResolvableValue
         # `MemoizableData.define` provides the following methods:
-        # @dynamic schema_element_names
+        # @dynamic schema
 
         def self.new(*fields, &block)
-          Support::MemoizableData.define(:schema_element_names, *fields) do
+          Support::MemoizableData.define(:schema, *fields) do
             # @implements ResolvableValueClass
             include ResolvableValue
             class_exec(&block) if block
@@ -41,7 +41,7 @@ module ElasticGraph
         end
 
         def canonical_name_for(name, element_type)
-          schema_element_names.canonical_name_for(name) ||
+          schema.element_names.canonical_name_for(name) ||
             raise(Errors::SchemaError, "#{element_type} `#{name}` is not a defined schema element")
         end
       end

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

@@ -126,6 +126,10 @@ module ElasticGraph
           raise Errors::NotFoundError, msg
         end
 
+        def fields_by_name_in_index
+          @fields_by_name_in_index ||= @fields_by_name.values.group_by(&:name_in_index)
+        end
+
         def enum_value_named(enum_value_name)
           @enum_values_by_name[enum_value_name]
         end