elasticgraph-graphql 0.19.2.2 → 1.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0966dcde797efc0d2e1f22901440b313e803a1db5cce33f79b515078901560c
-  data.tar.gz: 8508a1aafcbf466c4664dc95aaf2a112193df1a3f2edc92c40427ed8f96cd5a0
+  metadata.gz: 24f8c6670bb21bcf8936b9bd55cc2e3d6964e78ef9e3742881e720dc0e212404
+  data.tar.gz: 8b1de56fd5b6732905fb07fc4d2ece0480784104e6b860d42b0f62027463cef2
 SHA512:
-  metadata.gz: ccf09ea0494543be1b95d241d5592c1e35e4680b506c9776b1c823a83023af641c1ce4f71a305e8b733a72ef39d229f797aa8f1e21bfc2921a34cfb95d3c265b
-  data.tar.gz: c4df4204da85ff79eda7ecfefde640a6f9344c52426148074e95cbc9330328f8e526cb874d9aa3e869797953b4fe04fb31c7fe276119de767ead86068375ad53
+  metadata.gz: 399538281bc06bcea0a5ede7fc1c63990658def8aca9e9d2d22994e59d57d157fb0ef6b7d6c6b0270b528b278e8b77b3e20303bb9cbec2a5894bfccdc209e9fa
+  data.tar.gz: '072188ff912c10f81da236a0f5c9faab646976ad0bd33e57a0008bb2fc82add9e38896aa4e55331c308520145c4e79e6a5eba942e8f8b903862d05b29b2c82b6'

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

@@ -209,29 +209,9 @@ module ElasticGraph
             # New date/time grouping API (DateGroupedBy, DateTimeGroupedBy)
             if field.type.elasticgraph_category == :date_grouped_by_object
               date_time_groupings_from(field_path: field_path, node: node)
-
             elsif !field.type.object?
-              case field.type.name
-              # Legacy date grouping API
-              when "Date"
-                legacy_date_histogram_groupings_from(
-                  field_path: field_path,
-                  node: node,
-                  get_time_zone: ->(args) {},
-                  get_offset: ->(args) { args[element_names.offset_days]&.then { |days| "#{days}d" } }
-                )
-              # Legacy datetime grouping API
-              when "DateTime"
-                legacy_date_histogram_groupings_from(
-                  field_path: field_path,
-                  node: node,
-                  get_time_zone: ->(args) { args.fetch(element_names.time_zone) },
-                  get_offset: ->(args) { datetime_offset_from(node, args) }
-                )
               # Non-date/time grouping
-              else
-                [FieldTermGrouping.new(field_path: field_path)]
-              end
+              [FieldTermGrouping.new(field_path: field_path)]
             end
           end
         end
@@ -264,7 +244,7 @@ module ElasticGraph
                 field_path: child_field_path,
                 script_id: runtime_metadata.static_script_ids_by_scoped_name.fetch("field/as_time_of_day"),
                 params: {
-                  "interval" => interval_from(child_node, schema_args, interval_unit_key: element_names.truncation_unit),
+                  "interval" => interval_from(child_node, schema_args),
                   "offset_ms" => datetime_offset_as_ms_from(child_node, schema_args),
                   "time_zone" => time_zone
                 }
@@ -272,7 +252,7 @@ module ElasticGraph
             else
               DateHistogramGrouping.new(
                 field_path: child_field_path,
-                interval: interval_from(child_node, schema_args, interval_unit_key: element_names.truncation_unit),
+                interval: interval_from(child_node, schema_args),
                 offset: datetime_offset_from(child_node, schema_args),
                 time_zone: time_zone
               )
@@ -280,22 +260,10 @@ module ElasticGraph
           end
         end
 
-        def legacy_date_histogram_groupings_from(field_path:, node:, get_time_zone:, get_offset:)
-          schema_args = Schema::Arguments.to_schema_form(node.arguments, node.field)
-
-          [DateHistogramGrouping.new(
-            field_path: field_path,
-            interval: interval_from(node, schema_args, interval_unit_key: element_names.granularity),
-            time_zone: get_time_zone.call(schema_args),
-            offset: get_offset.call(schema_args)
-          )]
-        end
-
         # Figure out the Date histogram grouping interval for the given node based on the `grouped_by` argument.
-        # Until `legacy_grouping_schema` is removed, we need to check both `granularity` and `truncation_unit`.
-        def interval_from(node, schema_args, interval_unit_key:)
-          enum_type_name = node.field.arguments.fetch(interval_unit_key).type.unwrap.graphql_name
-          enum_value_name = schema_args.fetch(interval_unit_key)
+        def interval_from(node, schema_args)
+          enum_type_name = node.field.arguments.fetch(element_names.truncation_unit).type.unwrap.graphql_name
+          enum_value_name = schema_args.fetch(element_names.truncation_unit)
           enum_value = schema.type_named(enum_type_name).enum_value_named(enum_value_name)
 
           _ = enum_value.runtime_metadata.datastore_value

data/lib/elastic_graph/graphql/aggregation/resolvers/node.rb

@@ -29,7 +29,7 @@ module ElasticGraph
 
           def sub_aggregations
             @sub_aggregations ||= SubAggregations.new(
-              schema_element_names,
+              schema,
               query.sub_aggregations,
               parent_queries + [query],
               bucket,
@@ -42,7 +42,7 @@ module ElasticGraph
           end
 
           def count_detail
-            @count_detail ||= CountDetail.new(schema_element_names, bucket)
+            @count_detail ||= CountDetail.new(schema, bucket)
           end
 
           def cursor

data/lib/elastic_graph/graphql/aggregation/resolvers/relay_connection_builder.rb

@@ -15,18 +15,19 @@ module ElasticGraph
     module Aggregation
       module Resolvers
         module RelayConnectionBuilder
-          def self.build_from_search_response(query:, search_response:, schema_element_names:)
-            build_from_buckets(query: query, parent_queries: [], schema_element_names: schema_element_names) do
+          def self.build_from_search_response(query:, search_response:, schema:)
+            build_from_buckets(query: query, parent_queries: [], schema: schema) do
               extract_buckets_from(search_response, for_query: query)
             end
           end
 
-          def self.build_from_buckets(query:, parent_queries:, schema_element_names:, field_path: [], &build_buckets)
+          def self.build_from_buckets(query:, parent_queries:, schema:, field_path: [], &build_buckets)
             GraphQL::Resolvers::RelayConnection::GenericAdapter.new(
-              schema_element_names: schema_element_names,
-              raw_nodes: raw_nodes_for(query, parent_queries, schema_element_names, field_path, &build_buckets),
+              schema: schema,
+              raw_nodes: raw_nodes_for(query, parent_queries, schema, field_path, &build_buckets),
               paginator: query.paginator,
               get_total_edge_count: -> {},
+              edge_class: (_ = GraphQL::Resolvers::RelayConnection::GenericAdapter::Edge),
               to_sort_value: ->(node, decoded_cursor) do
                 query.groupings.map do |grouping|
                   DatastoreQuery::Paginator::SortValue.new(
@@ -39,13 +40,13 @@ module ElasticGraph
             )
           end
 
-          private_class_method def self.raw_nodes_for(query, parent_queries, schema_element_names, field_path)
+          private_class_method def self.raw_nodes_for(query, parent_queries, schema, field_path)
             # The `DecodedCursor::SINGLETON` is a special case, so handle it here.
             return [] if query.paginator.paginated_from_singleton_cursor?
 
             yield.map do |bucket|
               Node.new(
-                schema_element_names: schema_element_names,
+                schema: schema,
                 query: query,
                 parent_queries: parent_queries,
                 bucket: bucket,

data/lib/elastic_graph/graphql/aggregation/resolvers/sub_aggregations.rb

@@ -19,7 +19,7 @@ module ElasticGraph
   class GraphQL
     module Aggregation
       module Resolvers
-        class SubAggregations < ::Data.define(:schema_element_names, :sub_aggregations, :parent_queries, :sub_aggs_by_agg_key, :field_path)
+        class SubAggregations < ::Data.define(:schema, :sub_aggregations, :parent_queries, :sub_aggs_by_agg_key, :field_path)
           def resolve(field:, object:, args:, context:, lookahead:)
             path_segment = PathSegment.for(field: field, lookahead: lookahead)
             new_field_path = field_path + [path_segment]
@@ -31,7 +31,7 @@ module ElasticGraph
             RelayConnectionBuilder.build_from_buckets(
               query: sub_agg_query,
               parent_queries: parent_queries,
-              schema_element_names: schema_element_names,
+              schema: schema,
               field_path: new_field_path
             ) { extract_buckets(sub_agg_key, args) }
           end
@@ -41,7 +41,7 @@ module ElasticGraph
           def extract_buckets(aggregation_field_path, args)
             # When the client passes `first: 0`, we omit the sub-aggregation from the query body entirely,
             # and it wont' be in `sub_aggs_by_agg_key`. Instead, we can just return an empty list of buckets.
-            return [] if args[schema_element_names.first] == 0
+            return [] if args[schema.element_names.first] == 0
 
             sub_agg_key = Key.encode(parent_queries.map(&:name) + [aggregation_field_path])
             sub_agg = Support::HashUtil.verbose_fetch(sub_aggs_by_agg_key, sub_agg_key)

data/lib/elastic_graph/graphql/config.rb

@@ -20,12 +20,6 @@ module ElasticGraph
       :max_page_size,
       # Queries that take longer than this configured threshold will have a sanitized version logged.
       :slow_query_latency_warning_threshold_in_ms,
-      # How to resolve nested relationships:
-      #
-      # - `optimized` (default): uses the new (in ElasticGraph 0.19.2.0) optimized resolver logic.
-      # - `original`: uses the resolver logic from ElasticGraph v0.19.1.1 and before.
-      # - `comparison`: runs both versions of the logic in serial, to compare them for correctness and performance. Results are logged.
-      :nested_relationship_resolver_mode,
       # Object used to identify the client of a GraphQL query based on the HTTP request.
       :client_resolver,
       # Array of modules that will be extended onto the `GraphQL` instance to support extension libraries.
@@ -51,17 +45,10 @@ module ElasticGraph
           end
         end
 
-        nested_relationship_resolver_mode = parsed_yaml["nested_relationship_resolver_mode"]&.to_sym || :optimized
-        unless VALID_NESTED_RELATIONSHIP_RESOLVER_MODES.include?(nested_relationship_resolver_mode)
-          raise Errors::ConfigError, "Invalid value for `nested_relationship_resolver_mode`: #{nested_relationship_resolver_mode}. " \
-            "Valid values: #{VALID_NESTED_RELATIONSHIP_RESOLVER_MODES.join(", ")}."
-        end
-
         new(
           default_page_size: parsed_yaml.fetch("default_page_size"),
           max_page_size: parsed_yaml.fetch("max_page_size"),
           slow_query_latency_warning_threshold_in_ms: parsed_yaml["slow_query_latency_warning_threshold_in_ms"] || 5000,
-          nested_relationship_resolver_mode: nested_relationship_resolver_mode,
           client_resolver: load_client_resolver(parsed_yaml),
           extension_modules: extension_mods,
           extension_settings: entire_parsed_yaml.except(*ELASTICGRAPH_CONFIG_KEYS)
@@ -74,8 +61,6 @@ module ElasticGraph
       # The standard ElasticGraph root config setting keys; anything else is assumed to be extension settings.
       ELASTICGRAPH_CONFIG_KEYS = %w[graphql indexer logger datastore schema_artifacts]
 
-      VALID_NESTED_RELATIONSHIP_RESOLVER_MODES = [:optimized, :original, :comparison]
-
       private_class_method def self.load_client_resolver(parsed_yaml)
         config = parsed_yaml.fetch("client_resolver") do
           return Client::DefaultResolver.new({})

data/lib/elastic_graph/graphql/datastore_query.rb

@@ -29,8 +29,9 @@ module ElasticGraph
     class DatastoreQuery < Support::MemoizableData.define(
       :total_document_count_needed, :aggregations, :logger, :filter_interpreter, :routing_picker,
       :index_expression_builder, :default_page_size, :search_index_definitions, :max_page_size,
-      :filters, :sort, :document_pagination, :requested_fields, :individual_docs_needed,
-      :size_multiplier, :monotonic_clock_deadline, :schema_element_names
+      :client_filters, :internal_filters, :sort, :document_pagination,
+      :requested_fields, :request_all_fields, :requested_highlights, :request_all_highlights,
+      :individual_docs_needed, :size_multiplier, :monotonic_clock_deadline, :schema_element_names
     )
       # Load these files after the `Query` class has been defined, to avoid
       # `TypeError: superclass mismatch for class Query`
@@ -96,20 +97,34 @@ module ElasticGraph
       def merge_with(
         individual_docs_needed: false,
         total_document_count_needed: false,
-        filters: [],
+        client_filters: [],
+        internal_filters: [],
         sort: [],
         requested_fields: [],
+        request_all_fields: false,
+        requested_highlights: [],
+        request_all_highlights: false,
         document_pagination: {},
         size_multiplier: 1,
         monotonic_clock_deadline: nil,
         aggregations: {}
       )
+        individual_docs_needed ||= self.individual_docs_needed ||
+          !requested_fields.empty? || request_all_fields ||
+          !requested_highlights.empty? || request_all_highlights
+
+        total_document_count_needed ||= self.total_document_count_needed || aggregations.values.any?(&:needs_total_doc_count?)
+
         with(
-          individual_docs_needed: self.individual_docs_needed || individual_docs_needed || !requested_fields.empty?,
-          total_document_count_needed: self.total_document_count_needed || total_document_count_needed || aggregations.values.any?(&:needs_total_doc_count?),
-          filters: self.filters + filters,
+          individual_docs_needed: individual_docs_needed,
+          total_document_count_needed: total_document_count_needed,
+          client_filters: self.client_filters + client_filters,
+          internal_filters: self.internal_filters + internal_filters,
           sort: merge_attribute(:sort, sort),
           requested_fields: self.requested_fields + requested_fields,
+          request_all_fields: self.request_all_fields || request_all_fields,
+          requested_highlights: self.requested_highlights + requested_highlights,
+          request_all_highlights: self.request_all_highlights || request_all_highlights,
           document_pagination: merge_attribute(:document_pagination, document_pagination),
           size_multiplier: self.size_multiplier * size_multiplier,
           monotonic_clock_deadline: [self.monotonic_clock_deadline, monotonic_clock_deadline].compact.min,
@@ -128,7 +143,7 @@ module ElasticGraph
       # https://www.elastic.co/guide/en/elasticsearch/reference/current/multi-index.html
       def search_index_expression
         @search_index_expression ||= index_expression_builder.determine_search_index_expression(
-          filters,
+          all_filters,
           search_index_definitions,
           # When we have aggregations, we must require indices to search. When we search no indices, the datastore does not return
           # the standard aggregations response structure, which causes problems.
@@ -165,7 +180,7 @@ module ElasticGraph
       # `[]` means that we are routing to no shards.
       def shard_routing_values
         return @shard_routing_values if defined?(@shard_routing_values)
-        routing_values = routing_picker.extract_eligible_routing_values(filters, route_with_field_paths)
+        routing_values = routing_picker.extract_eligible_routing_values(all_filters, route_with_field_paths)
 
         @shard_routing_values ||=
           if routing_values&.empty? && !aggregations_datastore_body.empty?
@@ -238,6 +253,10 @@ module ElasticGraph
         document_paginator.effective_size
       end
 
+      def all_filters
+        client_filters + internal_filters
+      end
+
       private
 
       def merge_attribute(attribute, other_value)
@@ -284,8 +303,7 @@ module ElasticGraph
       def to_datastore_body
         @to_datastore_body ||= aggregations_datastore_body
           .merge(document_paginator.to_datastore_body)
-          .merge({query: filter_interpreter.build_query(filters)}.compact)
-          .merge({_source: source})
+          .merge({highlight: highlight, query: filter_interpreter.build_query(all_filters), _source: source}.compact)
       end
 
       def aggregations_datastore_body
@@ -304,6 +322,7 @@ module ElasticGraph
       # at all--which means the datastore can avoid decompressing the _source field. Otherwise,
       # we only ask for the fields we need to return.
       def source
+        return true if request_all_fields
         requested_source_fields = requested_fields - ["id"]
         return false if requested_source_fields.empty?
         # Merging in requested_fields as _source:{includes:} based on Elasticsearch documentation:
@@ -311,6 +330,19 @@ module ElasticGraph
         {includes: requested_source_fields.to_a}
       end
 
+      def highlight
+        return nil if !request_all_highlights && requested_highlights.empty?
+
+        # If there are no filters, there's nothing to highlight.
+        return nil if client_filters.empty?
+
+        field_paths = request_all_highlights ? ["*"] : requested_highlights
+        fields = field_paths.to_h { |field| [field, {}] }
+        highlight_query = filter_interpreter.build_query(client_filters) unless internal_filters.empty?
+
+        {fields:, highlight_query:}.compact
+      end
+
       # Encapsulates dependencies of `Query`, giving us something we can expose off of `application`
       # to build queries when desired.
       class Builder < Support::MemoizableData.define(:runtime_metadata, :logger, :filter_interpreter, :filter_node_interpreter, :default_page_size, :max_page_size)
@@ -330,12 +362,16 @@ module ElasticGraph
 
         def new_query(
           search_index_definitions:,
-          filters: [],
+          client_filters: [],
+          internal_filters: [],
           sort: [],
           document_pagination: {},
           size_multiplier: 1,
           aggregations: {},
           requested_fields: [],
+          request_all_fields: false,
+          requested_highlights: [],
+          request_all_highlights: false,
           individual_docs_needed: false,
           total_document_count_needed: false,
           monotonic_clock_deadline: nil
@@ -344,20 +380,29 @@ module ElasticGraph
             raise Errors::SearchFailedError, "Query is invalid, since it contains no `search_index_definitions`."
           end
 
+          individual_docs_needed ||= !requested_fields.empty? || request_all_fields ||
+            !requested_highlights.empty? || request_all_highlights
+
+          total_document_count_needed ||= aggregations.values.any?(&:needs_total_doc_count?)
+
           DatastoreQuery.new(
             routing_picker: routing_picker,
             index_expression_builder: index_expression_builder,
             logger: logger,
             schema_element_names: runtime_metadata.schema_element_names,
             search_index_definitions: search_index_definitions,
-            filters: filters.to_set,
+            client_filters: client_filters.to_set,
+            internal_filters: internal_filters.to_set,
             sort: sort,
             document_pagination: document_pagination,
             size_multiplier: size_multiplier,
             aggregations: aggregations,
             requested_fields: requested_fields.to_set,
-            individual_docs_needed: individual_docs_needed || !requested_fields.empty?,
-            total_document_count_needed: total_document_count_needed || aggregations.values.any?(&:needs_total_doc_count?),
+            requested_highlights: requested_highlights.to_set,
+            request_all_fields: request_all_fields,
+            request_all_highlights: request_all_highlights,
+            individual_docs_needed: individual_docs_needed,
+            total_document_count_needed: total_document_count_needed,
             monotonic_clock_deadline: monotonic_clock_deadline,
             filter_interpreter: filter_interpreter,
             default_page_size: default_page_size,

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

@@ -58,6 +58,10 @@ module ElasticGraph
           payload["version"]
         end
 
+        def highlights
+          raw_data["highlight"] || {}
+        end
+
         def cursor
           @cursor ||= decoded_cursor_factory.build(raw_data.fetch("sort"))
         end

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

@@ -13,16 +13,33 @@ module ElasticGraph
       # https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-bool-query.html
       #
       # It is composed of:
-      #   1) The occurrence type (:must, :filter, :should, or :must_not)
+      #   1) The occurrence type (:filter, :should, or :must_not)
       #   2) A list of query clauses evaluated by the given occurrence type
       #   3) An optional flag indicating whether the occurrence should be negated
+      #
+      # Note: since we never do anything with the score, we always prefer `filter` over `must`. If we ever
+      # decide to do something with the score (such as sorting by it), then we'll want to introduce `must`.
       class BooleanQuery < ::Data.define(:occurrence, :clauses)
-        def self.must(*clauses)
-          new(:must, clauses)
-        end
-
         def self.filter(*clauses)
-          new(:filter, clauses)
+          unwrapped_clauses = clauses.map do |clause|
+            __skip__ = case clause
+            in {bool: {minimum_should_match: 1, should: [::Hash => single_should], **nil}, **nil}
+              # This case represents an `anyOf` with a single subfilter (`filter: {anyOf: [X]}`).
+              # Such an expression is semantically equivalent to `filter: X`, and we can unwrap the
+              # should clause in this case since there is only a single one.
+              #
+              # While it adds a bit of complexity to do this unwrapping, we believe it's worth it because
+              # it preserves the datastore's ability to apply caching. As the Elasticsearch documentation[^1]
+              # explains, the results of `filter` clauses can be cached, but not `should` clauses.
+              #
+              # [^1]: https://www.elastic.co/docs/reference/query-languages/query-dsl/query-dsl-bool-query
+              single_should
+            else
+              clause
+            end
+          end
+
+          new(:filter, unwrapped_clauses)
         end
 
         def self.should(*clauses)

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

@@ -90,33 +90,64 @@ module ElasticGraph
             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"
-                    }
-                  }
-                }
-              )
+              BooleanQuery.filter({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)
-                    }
-                  }
-                }
-              )
+              BooleanQuery.filter({match_phrase_prefix: {field_name => {
+                query: value.fetch(schema_names.phrase)
+              }}})
+            },
+
+            schema_names.contains => ->(field_name, value) {
+              case_insensitive = value[schema_names.ignore_case] || false
+              anded_substrings = value[schema_names.all_substrings_of] || []
+              ored_substrings = value[schema_names.any_substring_of]
+
+              sub_expressions = anded_substrings.map do |substring|
+                substring_clause(field_name, substring, case_insensitive)
+              end
+
+              if ored_substrings
+                should_sub_expressions = ored_substrings.map do |substring|
+                  substring_clause(field_name, substring, case_insensitive)
+                end
+
+                sub_expressions << {bool: {minimum_should_match: 1, should: should_sub_expressions}}
+              end
+
+              if ored_substrings&.empty?
+                BooleanQuery::ALWAYS_FALSE_FILTER
+              elsif sub_expressions.size > 0
+                BooleanQuery.filter(*sub_expressions)
+              end
+            },
+
+            schema_names.starts_with => ->(field_name, value) {
+              case_insensitive = value[schema_names.ignore_case] || false
+              ored_prefixes = value[schema_names.any_prefix_of]
+
+              sub_expressions = (ored_prefixes || []).map do |prefix|
+                {prefix: {field_name => {
+                  value: prefix,
+                  case_insensitive: case_insensitive
+                }}}
+              end
+
+              if ored_prefixes&.empty?
+                BooleanQuery::ALWAYS_FALSE_FILTER
+              elsif sub_expressions.size > 0
+                BooleanQuery.filter({bool: {minimum_should_match: 1, should: sub_expressions}})
+              end
             },
 
             # This filter operator wraps a geo distance query:
@@ -163,6 +194,15 @@ module ElasticGraph
           }.freeze
         end
 
+        def substring_clause(field_name, substring, case_insensitive)
+          {wildcard: {field_name => {
+            # We squeeze("*") to convert "**" to "*", which is not needed for correctness but is a bit simpler.
+            # There's no point in two consecutive "*" wildcards.
+            value: "*#{substring}*".squeeze("*"),
+            case_insensitive: case_insensitive
+          }}}
+        end
+
         def to_datastore_value(value)
           case value
           when ::Array

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

@@ -43,9 +43,15 @@ module ElasticGraph
         def query_attributes_for(field:, lookahead:)
           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))
+                requested_fields: requested_fields_under(relay_connection_node_from(lookahead)),
+                request_all_highlights: requesting_all_highlights?(lookahead),
+                requested_highlights: requested_fields_under(highlights)
               }
             else
               {
@@ -127,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/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

@@ -17,14 +17,17 @@ module ElasticGraph
         # here we just adapt it to the ElasticGraph internal resolver interface.
         class ArrayAdapter < ResolvableValue.new(:graphql_impl)
           # `ResolvableValue.new` provides the following methods:
-          # @dynamic initialize, graphql_impl, 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)
+          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
@@ -34,7 +37,7 @@ module ElasticGraph
             end.compact
 
             graphql_impl = ::GraphQL::Pagination::ArrayConnection.new(nodes || [], context: context, **relay_args)
-            new(schema_element_names, graphql_impl)
+            new(schema, graphql_impl)
           end
 
           def total_edge_count
@@ -47,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
 
@@ -58,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/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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elasticgraph-graphql
 version: !ruby/object:Gem::Version
-  version: 0.19.2.2
+  version: 1.0.0.rc1
 platform: ruby
 authors:
 - Myron Marston
@@ -9,7 +9,7 @@ authors:
 - Block Engineering
 bindir: bin
 cert_chain: []
-date: 2025-05-05 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -31,42 +31,42 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.2.2
+        version: 1.0.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.2.2
+        version: 1.0.0.rc1
 - !ruby/object:Gem::Dependency
   name: elasticgraph-schema_artifacts
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.2.2
+        version: 1.0.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.2.2
+        version: 1.0.0.rc1
 - !ruby/object:Gem::Dependency
   name: graphql
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.5.4
+        version: 2.5.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.5.4
+        version: 2.5.6
 - !ruby/object:Gem::Dependency
   name: graphql-c_parser
   requirement: !ruby/object:Gem::Requirement
@@ -76,7 +76,7 @@ dependencies:
         version: '1.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.2
+        version: 1.1.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -86,77 +86,77 @@ dependencies:
         version: '1.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.2
+        version: 1.1.3
 - !ruby/object:Gem::Dependency
   name: elasticgraph-admin
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.2.2
+        version: 1.0.0.rc1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.2.2
+        version: 1.0.0.rc1
 - !ruby/object:Gem::Dependency
   name: elasticgraph-elasticsearch
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.2.2
+        version: 1.0.0.rc1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.2.2
+        version: 1.0.0.rc1
 - !ruby/object:Gem::Dependency
   name: elasticgraph-opensearch
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.2.2
+        version: 1.0.0.rc1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.2.2
+        version: 1.0.0.rc1
 - !ruby/object:Gem::Dependency
   name: elasticgraph-indexer
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.2.2
+        version: 1.0.0.rc1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.2.2
+        version: 1.0.0.rc1
 - !ruby/object:Gem::Dependency
   name: elasticgraph-schema_definition
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.2.2
+        version: 1.0.0.rc1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.2.2
+        version: 1.0.0.rc1
 email:
 - myron@squareup.com
 executables: []
@@ -247,10 +247,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/block/elasticgraph/issues
-  changelog_uri: https://github.com/block/elasticgraph/releases/tag/v0.19.2.2
-  documentation_uri: https://block.github.io/elasticgraph/api-docs/v0.19.2.2/
+  changelog_uri: https://github.com/block/elasticgraph/releases/tag/v1.0.0.rc1
+  documentation_uri: https://block.github.io/elasticgraph/api-docs/v1.0.0.rc1/
   homepage_uri: https://block.github.io/elasticgraph/
-  source_code_uri: https://github.com/block/elasticgraph/tree/v0.19.2.2/elasticgraph-graphql
+  source_code_uri: https://github.com/block/elasticgraph/tree/v1.0.0.rc1/elasticgraph-graphql
   gem_category: core
 rdoc_options: []
 require_paths:
@@ -259,7 +259,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.4'
   - - "<"
     - !ruby/object:Gem::Version
       version: '3.5'
@@ -269,7 +269,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
 summary: The ElasticGraph GraphQL query engine.
 test_files: []