elasticgraph-graphql 0.19.3.0 → 1.0.0.rc1

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

@@ -41,22 +41,21 @@ module ElasticGraph
         end
 
         def query_attributes_for(field:, lookahead:)
-          index_field_paths =
-            field.type
-              .unwrap_fully
-              .search_index_definitions
-              .flat_map { |index_def| index_def.fields_by_path.keys }
-              .to_set
-
           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)),
+                request_all_highlights: requesting_all_highlights?(lookahead),
+                requested_highlights: requested_fields_under(highlights)
               }
             else
               {
-                requested_fields: requested_fields_under(lookahead, index_field_paths)
+                requested_fields: requested_fields_under(lookahead)
               }
             end
 
@@ -75,9 +74,9 @@ module ElasticGraph
         # can ignore its foreign key; but when we are determining requested fields for a parent type,
         # we need to identify the foreign key to request from the datastore, without recursing into
         # its children.
-        def requested_fields_under(node, index_field_paths, path_prefix: "")
+        def requested_fields_under(node, path_prefix: "")
           fields = node.selections.flat_map do |child|
-            requested_fields_for(child, index_field_paths, path_prefix: path_prefix)
+            requested_fields_for(child, path_prefix: path_prefix)
           end
 
           fields << "#{path_prefix}__typename" if field_for(node.field)&.type&.abstract?
@@ -86,22 +85,14 @@ module ElasticGraph
 
         # Identifies the fields we need to fetch from the datastore for the given node,
         # and recursing into the fields under it as needed.
-        def requested_fields_for(node, index_field_paths, path_prefix:)
+        def requested_fields_for(node, path_prefix:)
           return [] if graphql_dynamic_field?(node)
 
           # @type var field: Schema::Field
           field = _ = field_for(node.field)
 
           if field.type.embedded_object?
-            field_path = "#{path_prefix}#{field.name_in_index}"
-            if index_field_paths.include?(field_path)
-              # If we've reached a path to a scalar field, we should just return it instead of recursing.
-              # This allows an object field to use a `name_in_index` of a scalar field which can be
-              # necessary for some custom resolvers.
-              [field_path]
-            else
-              requested_fields_under(node, index_field_paths, path_prefix: "#{field_path}.")
-            end
+            requested_fields_under(node, path_prefix: "#{path_prefix}#{field.name_in_index}.")
           else
             field.index_field_names_for_resolution.map do |name|
               "#{path_prefix}#{name}"
@@ -142,6 +133,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/graphql_adapter_builder.rb

@@ -17,11 +17,7 @@ module ElasticGraph
       class GraphQLAdapterBuilder
         def initialize(runtime_metadata:, named_resolvers:, query_adapter:)
           @runtime_metadata = runtime_metadata
-          @resolvers_by_name_and_field_config = named_resolvers.transform_values do |resolver_constructor|
-            ::Hash.new do |hash, field_config|
-              hash[field_config] = resolver_constructor.call(field_config)
-            end
-          end
+          @named_resolvers = named_resolvers
           @query_adapter = query_adapter
         end
 
@@ -46,10 +42,10 @@ module ElasticGraph
         def object_type_hash
           @runtime_metadata.object_types_by_name.filter_map do |type_name, type|
             fields_hash = type.graphql_fields_by_name.filter_map do |field_name, field|
-              if (configured_resolver = field.resolver)
-                resolver = @resolvers_by_name_and_field_config.fetch(configured_resolver.name) do
-                  raise Errors::SchemaError, "Resolver `#{configured_resolver.name}` (for `#{type_name}.#{field_name}`) cannot be found."
-                end[configured_resolver.config]
+              if (resolver_name = field.resolver)
+                resolver = @named_resolvers.fetch(resolver_name) do
+                  raise Errors::SchemaError, "Resolver `#{resolver_name}` (for `#{type_name}.#{field_name}`) cannot be found."
+                end
 
                 resolver_lambda =
                   if resolver.method(:resolve).parameters.include?([:keyreq, :lookahead])

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/relay_connection/array_adapter.rb

@@ -15,32 +15,33 @@ module ElasticGraph
       module RelayConnection
         # Relay connection adapter for an array. Implemented primarily by `GraphQL::Relay::ArrayConnection`;
         # here we just adapt it to the ElasticGraph internal resolver interface.
-        class ArrayAdapter < ResolvableValue.new(:graphql_impl, :total_edge_count)
+        class ArrayAdapter < ResolvableValue.new(:graphql_impl)
           # `ResolvableValue.new` provides the following methods:
-          # @dynamic initialize, graphql_impl, total_edge_count, schema_element_names
+          # @dynamic initialize, graphql_impl, 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)
-            nodes ||= [] # : ::Array[untyped]
+          def self.build(nodes, args, context)
+            schema = context.fetch(:elastic_graph_schema)
+            schema_element_names = schema.element_names
+
             # 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
             # understand them.
-            #
-            # `after` and `before` are encoded to convert them to the string form required by `ArrayConnection`.
-            relay_args = {
-              first: args[schema_element_names.first],
-              after: args[schema_element_names.after]&.encode,
-              last: args[schema_element_names.last],
-              before: args[schema_element_names.before]&.encode
-            }.compact
+            relay_args = [:first, :after, :last, :before].to_h do |arg_name|
+              [arg_name, args[schema_element_names.public_send(arg_name)]]
+            end.compact
+
+            graphql_impl = ::GraphQL::Pagination::ArrayConnection.new(nodes || [], context: context, **relay_args)
+            new(schema, graphql_impl)
+          end
 
-            graphql_impl = ::GraphQL::Pagination::ArrayConnection.new(nodes, context: context, **relay_args)
-            new(schema_element_names, graphql_impl, nodes.size)
+          def total_edge_count
+            graphql_impl.nodes.size
           end
 
           def page_info
@@ -49,7 +50,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 +61,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.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/field.rb

@@ -29,7 +29,7 @@ module ElasticGraph
           @computation_detail = runtime_metadata&.computation_detail
           @resolver = runtime_metadata&.resolver
           @name_in_index = runtime_metadata&.name_in_index || name
-          @graphql_field.extras([:lookahead]) if resolvers_needing_lookahead.include?(@resolver&.name)
+          @graphql_field.extras([:lookahead]) if resolvers_needing_lookahead.include?(@resolver)
         end
 
         def type

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

data/lib/elastic_graph/graphql.rb

@@ -183,13 +183,7 @@ module ElasticGraph
     def named_graphql_resolvers
       @named_graphql_resolvers ||= runtime_metadata.graphql_resolvers_by_name.transform_values do |resolver|
         ext = resolver.load_resolver
-
-        ->(field_config) do
-          (_ = ext.extension_class).new(
-            elasticgraph_graphql: self,
-            config: ext.config.merge(field_config)
-          )
-        end
+        (_ = ext.extension_class).new(elasticgraph_graphql: self, config: ext.config)
       end
     end