elasticgraph-graphql 0.19.0.0.rc1 → 0.19.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01af70cea7a26c2897ca64c179e0ed5a9a482a9229a46304b2e59b2f249148c3
-  data.tar.gz: 9a6aca68a2663012e54bf022a7153ec4443b3bc59846c63b91e6084b07b61574
+  metadata.gz: 87e3b12d1297421b2631906b7c682d38f87d4111fc9929d56d2be55f6cc481fe
+  data.tar.gz: bb454a309d0869c7c0d446d5ca2882cda4d005e412966db327e3dab56c0916f8
 SHA512:
-  metadata.gz: 5ead565225393723335e8dcc0dea15a6858dd005e5f96531ad60aa21b2cf0166760cb5c25e788b0dbb5d367c50ddb1335f9fd5129a2ee173df0d04c436e5ed15
-  data.tar.gz: fc360a136de5620ac53375046dce9e93a90b19f4ea3eb2331f8ca2dbda2f2701b55156e04ac60f71ab4bf45c5eca4e45a2efcf2236cef25f78503ef1beca5cda
+  metadata.gz: 803c34dfff0d787e61987f5d1877ea93485180161d3f1fc730bf6989d52f17e929c7fe476b434d4d59d59acf86622c5f68e6b2ed2f050df4abcdc13257c33bb8
+  data.tar.gz: 505707f3dd8bab37cc388cc542c343d4a541f5354c8e192d131a3cff36096e2d1ad9578872a68b169806f476acf0bdfd46d4db5389bb8e1dce09a984745265df

data/elasticgraph-graphql.gemspec

@@ -13,7 +13,7 @@ ElasticGraphGemspecHelper.define_elasticgraph_gem(gemspec_file: __FILE__, catego
 
   spec.add_dependency "elasticgraph-datastore_core", eg_version
   spec.add_dependency "elasticgraph-schema_artifacts", eg_version
-  spec.add_dependency "graphql", "~> 2.4.5"
+  spec.add_dependency "graphql", "~> 2.4.8"
 
   spec.add_development_dependency "elasticgraph-admin", eg_version
   spec.add_development_dependency "elasticgraph-elasticsearch", eg_version

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

@@ -154,7 +154,7 @@ module ElasticGraph
           # If there are no aggregations, there's nothing to unmerge--just return it as is.
           return response_from_merged_query unless (aggs = response_from_merged_query["aggregations"])
 
-          prefix = @unique_prefix_by_query[original_query]
+          prefix = @unique_prefix_by_query[original_query] # : ::String
           agg_names = original_query.aggregations.keys.map { |name| "#{prefix}#{name}" }.to_set
 
           filtered_aggs = aggs

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

@@ -14,8 +14,13 @@ module ElasticGraph
     class DatastoreQuery
       # Responsible for building a search index expression for a specific query based on the filters.
       class IndexExpressionBuilder
-        def initialize(schema_names:)
-          @filter_value_set_extractor = Filtering::FilterValueSetExtractor.new(schema_names, Support::TimeSet::ALL, Support::TimeSet::EMPTY) do |operator, filter_value|
+        def initialize(filter_node_interpreter:, schema_names:)
+          @filter_value_set_extractor = Filtering::FilterValueSetExtractor.new(
+            filter_node_interpreter,
+            schema_names,
+            Support::TimeSet::ALL,
+            Support::TimeSet::EMPTY
+          ) do |operator, filter_value|
             case operator
             when :gt, :gte, :lt, :lte
               if date_string?(filter_value)
@@ -73,6 +78,8 @@ module ElasticGraph
 
           time_set = @filter_value_set_extractor.extract_filter_value_set(filter_hashes, [index_def.timestamp_field_path])
 
+          return IndexExpression.only(index_def.index_expression_for_search) if time_set.nil?
+
           if time_set.empty?
             return require_indices ?
               # Indices are required. Given the time set is empty, it's impossible for any documents to match our search.

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

@@ -13,21 +13,19 @@ module ElasticGraph
     class DatastoreQuery
       # Responsible for picking routing values for a specific query based on the filters.
       class RoutingPicker
-        def initialize(schema_names:)
-          # @type var all_values_set: _RoutingValueSet
+        def initialize(filter_node_interpreter:, schema_names:)
           all_values_set = RoutingValueSet::ALL
           empty_set = RoutingValueSet::EMPTY
 
-          @filter_value_set_extractor = Filtering::FilterValueSetExtractor.new(schema_names, all_values_set, empty_set) do |operator, filter_value|
+          @filter_value_set_extractor = Filtering::FilterValueSetExtractor.new(
+            filter_node_interpreter,
+            schema_names,
+            all_values_set,
+            empty_set
+          ) do |operator, filter_value|
             if operator == :equal_to_any_of
               # This calls `.compact` to remove `nil` filter_value values
               RoutingValueSet.of(filter_value.compact)
-            else # gt, lt, gte, lte, matches
-              # With one of these inexact/inequality operators, we don't have a way to precisely represent
-              # the set of values. Instead, we represent it with the special UnboundedWithExclusions
-              # implementation since when these operators are used the set is unbounded (there's an infinite
-              # number of values in the set) but it doesn't contain all values (it has some exclusions).
-              RoutingValueSet::UnboundedWithExclusions
             end
           end
         end
@@ -55,13 +53,11 @@ module ElasticGraph
         # end
         # ```
         def extract_eligible_routing_values(filter_hashes, routing_field_paths)
-          @filter_value_set_extractor.extract_filter_value_set(filter_hashes, routing_field_paths).to_return_value
+          @filter_value_set_extractor.extract_filter_value_set(filter_hashes, routing_field_paths)&.to_return_value
         end
       end
 
       class RoutingValueSet < Data.define(:type, :routing_values)
-        # @dynamic ==
-
         def self.of(routing_values)
           new(:inclusive, routing_values.to_set)
         end
@@ -73,15 +69,7 @@ module ElasticGraph
         ALL = of_all_except([])
         EMPTY = of([])
 
-        def intersection(other_set)
-          # Here we return `self` to preserve the commutative property of `intersection`. Returning `self`
-          # here matches the behavior of `UnboundedWithExclusions.intersection`. See the comment there for
-          # rationale.
-          return self if other_set == UnboundedWithExclusions
-
-          # @type var other: RoutingValueSet
-          other = _ = other_set
-
+        def intersection(other)
           if inclusive? && other.inclusive?
             # Since both sets are inclusive, we can just delegate to `Set#intersection` here.
             RoutingValueSet.of(routing_values.intersection(other.routing_values))
@@ -111,15 +99,7 @@ module ElasticGraph
           end
         end
 
-        def union(other_set)
-          # Here we return `other` to preserve the commutative property of `union`. Returning `other`
-          # here matches the behavior of `UnboundedWithExclusions.union`. See the comment there for
-          # rationale.
-          return other_set if other_set == UnboundedWithExclusions
-
-          # @type var other: RoutingValueSet
-          other = _ = other_set
-
+        def union(other)
           if inclusive? && other.inclusive?
             # Since both sets are inclusive, we can just delegate to `Set#union` here.
             RoutingValueSet.of(routing_values.union(other.routing_values))
@@ -180,52 +160,6 @@ module ElasticGraph
         def get_included_and_excluded_values(other)
           inclusive? ? [routing_values, other.routing_values] : [other.routing_values, routing_values]
         end
-
-        # This `RoutingValueSet` implementation is used for otherwise unrepresentable cases. We use it when
-        # a filter on one of the `routing_field_paths` uses an inequality like:
-        #
-        #     {routing_field: {gt: "abc"}}
-        #
-        # In a case like that, the set is unbounded (there's an infinite number of values that are greater
-        # than `"abc"`...), but it's not `RoutingValueSet::ALL`--since it's based on an inequality, there are
-        # _some_ values that are excluded from the set. But we can't use `RoutingValueSet.of_all_except(...)`
-        # because the set of exclusions is also unbounded!
-        #
-        # When our filter value extraction results in this set, we must search all shards of the index and
-        # cannot pass any `routing` value to the datastore at all.
-        module UnboundedWithExclusions
-          # @dynamic self.==
-
-          def self.intersection(other)
-            # Technically, the "true" intersection would be `other - values_of(self)` but as we don't have
-            # any known values from this unbounded set, we just return `other`. It's OK to include extra values
-            # in the set (we'll search additional shards) but not OK to fail to include necessary values in
-            # the set (we'd avoid searching a shard that may have matching documents) so we err on the side of
-            # including more values.
-            other
-          end
-
-          def self.union(other)
-            # Since our set here is unbounded, the resulting union is also unbounded. This errs on the side
-            # of safety since this set's `to_return_value` returns `nil` to cause the datastore to search
-            # all shards.
-            self
-          end
-
-          def self.negate
-            # This here is the only difference in behavior of this set implementation vs `RoutingValueSet::ALL`.
-            # Where as `ALL.negate` returns an empty set, we treat `negate` as a no-op. We do that because the
-            # negation of an inexact unbounded set is still an inexact unbounded set. While it flips which values
-            # are in or out of the set, this object is still the representation in our datamodel for that case.
-            self
-          end
-
-          def self.to_return_value
-            # Here we return `nil` to make sure that the datastore searches all shards, since we don't have
-            # any information we can use to safely limit what shards it searches.
-            nil
-          end
-        end
       end
 
       # `Query::RoutingPicker` exists only for use by `Query` and is effectively private.

data/lib/elastic_graph/graphql/datastore_query.rb

@@ -344,17 +344,23 @@ module ElasticGraph
 
       # 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, :query_defaults)
-        def self.with(runtime_metadata:, logger:, **query_defaults)
-          new(runtime_metadata: runtime_metadata, logger: logger, query_defaults: query_defaults)
+      class Builder < Support::MemoizableData.define(:runtime_metadata, :logger, :filter_node_interpreter, :query_defaults)
+        def self.with(runtime_metadata:, logger:, filter_node_interpreter:, **query_defaults)
+          new(runtime_metadata:, logger:, filter_node_interpreter:, query_defaults:)
         end
 
         def routing_picker
-          @routing_picker ||= RoutingPicker.new(schema_names: runtime_metadata.schema_element_names)
+          @routing_picker ||= RoutingPicker.new(
+            filter_node_interpreter: filter_node_interpreter,
+            schema_names: runtime_metadata.schema_element_names
+          )
         end
 
         def index_expression_builder
-          @index_expression_builder ||= IndexExpressionBuilder.new(schema_names: runtime_metadata.schema_element_names)
+          @index_expression_builder ||= IndexExpressionBuilder.new(
+            filter_node_interpreter: filter_node_interpreter,
+            schema_names: runtime_metadata.schema_element_names
+          )
         end
 
         def new_query(**options)

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

@@ -26,7 +26,7 @@ module ElasticGraph
         # vs GraphQL.
         def translate_filter_args(field:, args:)
           return nil unless (filter_hash = args[filter_arg_name])
-          filter_type = field.schema.type_from(field.graphql_field.arguments[filter_arg_name].type)
+          filter_type = field.schema.type_from(field.graphql_field.arguments.fetch(filter_arg_name).type)
           convert(filter_type, filter_hash)
         end
 

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

@@ -137,8 +137,6 @@ module ElasticGraph
         # this because we do not generate `any_satisfy` filters on `object` list fields (instead,
         # they get generated on their leaf fields).
         def process_list_any_filter_expression(bool_node, filter, field_path)
-          return if filter.nil? || filter == {}
-
           if filters_on_sub_fields?(filter)
             process_any_satisfy_filter_expression_on_nested_object_list(bool_node, filter, field_path)
           else
@@ -195,8 +193,6 @@ module ElasticGraph
         # * `filter: {anyOf: [{field: null}]}` -> return all results
         # * `filter: {anyOf: [{field: null}, {field: ...}]}` -> return all results
         def process_any_of_expression(bool_node, expressions, field_path)
-          return if expressions.nil? || expressions == {}
-
           if expressions.empty?
             # When our `expressions` array is empty, we want to match no documents. However, that's
             # not the behavior the datastore will give us if we have an empty array in the query under
@@ -218,8 +214,6 @@ module ElasticGraph
         end
 
         def process_all_of_expression(bool_node, expressions, field_path)
-          return if expressions.nil? || expressions == {}
-
           # `all_of` represents an AND. AND is the default way that `process_filter_hash` combines
           # filters so we just have to call it for each sub-expression.
           expressions.each do |sub_expression|
@@ -228,8 +222,6 @@ module ElasticGraph
         end
 
         def process_operator_expression(bool_node, operator, expression, field_path)
-          return if expression.nil? || expression == {}
-
           # `operator` is a filtering operator, and `expression` is the value the filtering
           # operator should be applied to. The `op_applicator` lambda, when called, will
           # return a Clause instance (defined in this module).
@@ -317,8 +309,6 @@ module ElasticGraph
         end
 
         def process_list_count_expression(bool_node, expression, field_path)
-          return if expression.nil? || expression == {}
-
           # Normally, we don't have to do anything special for list count expressions.
           # That's the case, for example, for an expression like:
           #

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

@@ -25,33 +25,30 @@ module ElasticGraph
         end
 
         def identify_node_type(field_or_op, sub_expression)
-          identify_by_field_or_op(field_or_op) || identify_by_sub_expr(sub_expression) || :unknown
-        end
-
-        def filter_operators
-          @filter_operators ||= build_filter_operators(runtime_metadata)
-        end
+          # `:not` must go before `:empty`, because `not: empty_filter` must be inverted from just  `empty_filter`.
+          return :not if field_or_op == schema_names.not
 
-        private
+          # The `:empty` check can go before all other checks; besides `not`, none of the other operators require special
+          # handling when the filter is empty, and we want to detect this as early as possible.
+          # Note: `any_of: [empty_filter]` does have special handling, but `any_of: empty_filter` does not.
+          return :empty if sub_expression.nil? || sub_expression == {}
 
-        def identify_by_field_or_op(field_or_op)
-          return :not if field_or_op == schema_names.not
           return :list_any_filter if field_or_op == schema_names.any_satisfy
           return :all_of if field_or_op == schema_names.all_of
           return :any_of if field_or_op == schema_names.any_of
           return :operator if filter_operators.key?(field_or_op)
           return :list_count if field_or_op == LIST_COUNTS_FIELD
+          return :sub_field if sub_expression.is_a?(::Hash)
 
-          nil
+          :unknown
         end
 
-        def identify_by_sub_expr(sub_expression)
-          return :empty if sub_expression.nil? || sub_expression == {}
-          return :sub_field if sub_expression.is_a?(::Hash)
-
-          nil
+        def filter_operators
+          @filter_operators ||= build_filter_operators(runtime_metadata)
         end
 
+        private
+
         def build_filter_operators(runtime_metadata)
           filter_by_time_of_day_script_id = runtime_metadata
             .static_script_ids_by_scoped_name

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

@@ -12,7 +12,8 @@ module ElasticGraph
       # Responsible for extracting a set of values from query filters, based on a using a custom
       # set type that is able to efficiently model the "all values" case.
       class FilterValueSetExtractor
-        def initialize(schema_names, all_values_set, empty_set, &build_set_for_filter)
+        def initialize(filter_node_interpreter, schema_names, all_values_set, empty_set, &build_set_for_filter)
+          @filter_node_interpreter = filter_node_interpreter
           @schema_names = schema_names
           @all_values_set = all_values_set
           @empty_set = empty_set
@@ -41,9 +42,12 @@ module ElasticGraph
           # routing values causes no adverse behavior (although it may introduce an inefficiency)
           # but if we fail to route to a shard that contains a matching document, the search results
           # will be incorrect.
-          map_reduce_sets(target_field_paths, :union, negate: false) do |target_field_path|
+          value_set = map_reduce_sets(target_field_paths, :union, negate: false) do |target_field_path|
             filter_value_set_for_target_field_path(target_field_path, filter_hashes)
           end
+
+          return nil if (_ = value_set) == UnboundedSetWithExclusions
+          _ = value_set
         end
 
         private
@@ -83,24 +87,32 @@ module ElasticGraph
         # the key could identify either a field we are filtering on or a filtering operator to apply
         # to a particular field.
         def filter_value_set_for_filter_hash_entry(field_or_op, filter_value, target_field_path_parts, traversed_field_path_parts, negate:)
-          if filter_value.nil?
-            # Any filter with a `nil` value is effectively treated as `true` by our filtering logic, so we need
+          node_type = @filter_node_interpreter.identify_node_type(field_or_op, filter_value)
+          case node_type
+          when :empty
+            # Any empty filter is effectively treated as `true` by our filtering logic, so we need
             # to return our `@all_values_set` to indicate this filter matches all documents.
             @all_values_set
-          elsif field_or_op == @schema_names.not
-            filter_value_set_for_filter_hash(filter_value, target_field_path_parts, traversed_field_path_parts, negate: !negate)
-          elsif filter_value.is_a?(::Hash)
-            # the only time `value` is a hash is when `field_or_op` is a field name.
-            # In that case, `value` is a hash of filters that apply to that field.
+          when :not
+            filter_value_set_for_filter_hash(filter_value || {}, target_field_path_parts, traversed_field_path_parts, negate: !negate)
+          when :sub_field
             filter_value_set_for_filter_hash(filter_value, target_field_path_parts, traversed_field_path_parts + [field_or_op], negate: negate)
-          elsif field_or_op == @schema_names.any_of
+          when :any_of
             filter_value_set_for_any_of(filter_value, target_field_path_parts, traversed_field_path_parts, negate: negate)
-          elsif target_field_path_parts == traversed_field_path_parts
+          when :operator
+            # Check to make sure the operator applies to the target field. If not, we have no information
+            # in this clause. The set is unbounded, and may have exclusions.
+            return UnboundedSetWithExclusions unless target_field_path_parts == traversed_field_path_parts
+
             set = filter_value_set_for_field_filter(field_or_op, filter_value)
             negate ? set.negate : set
+          when :all_of, :list_any_filter, :list_count, :unknown
+            # We have no information in this clause. The set is unbounded, and may have exclusions.
+            UnboundedSetWithExclusions
           else
-            # Otherwise, we have no information in this clause to limit our filter value set.
-            @all_values_set
+            # :nocov: -- not possible to cover without mocking `@filter_node_interpreter` to return a node type outside the allowed values.
+            raise "`FilterValueSetExtractor` must be updated to handle `:#{node_type}` nodes."
+            # :nocov:
           end
         end
 
@@ -125,7 +137,7 @@ module ElasticGraph
         # Determines the set of filter values for a single filter on a single field.
         def filter_value_set_for_field_filter(filter_op, filter_value)
           operator_name = @schema_names.canonical_name_for(filter_op)
-          @build_set_for_filter.call(operator_name, filter_value) || @all_values_set
+          @build_set_for_filter.call(operator_name, filter_value) || UnboundedSetWithExclusions
         end
 
         # Maps over the provided `collection` by applying the given `map_transform`
@@ -144,10 +156,49 @@ module ElasticGraph
           # of each set is the difference between @all_values_set and the given set)--and vice versa.
           reduction = REDUCTION_INVERSIONS.fetch(reduction) if negate
 
-          collection.map(&map_transform).reduce(reduction)
+          collection.map(&map_transform).reduce do |s1, s2|
+            receiver, argument = ((_ = s2) == UnboundedSetWithExclusions) ? [s2, s1] : [s1, s2]
+            (reduction == :union) ? receiver.union(argument) : receiver.intersection(argument)
+          end
         end
 
         REDUCTION_INVERSIONS = {union: :intersection, intersection: :union}
+
+        # This minimal set implementation is used for otherwise unrepresentable cases. We use it when
+        # a filter on a `target_field_path` uses an inequality like:
+        #
+        #     {field: {gt: "abc"}}
+        #
+        # In a case like that, the set is unbounded (there's an infinite number of values that are greater
+        # than `"abc"`...), but it's not `@all_values_set`--since it's based on an inequality, there are
+        # _some_ values that are excluded from the set. We also can't represent this case with an
+        # `all_values_except(...)` set implementation because the set of exclusions is also unbounded!
+        #
+        # When our filter value extraction results in this set, we cannot limit what shards or indices we must hit based
+        # on the filters.
+        module UnboundedSetWithExclusions
+          def self.intersection(other)
+            # Technically, the accurate intersection would be `other - values_of(self)` but as we don't have
+            # any known values from this unbounded set, we just return `other`. It's OK to include extra values
+            # in the set (we'll search additional shards or indices) but not OK to fail to include necessary values
+            # in the set (we'd avoid searching a shard that may have matching documents) so we err on the side of
+            # including more values.
+            other
+          end
+
+          def self.union(other)
+            # Since our set here is unbounded, the resulting union is also unbounded.
+            self
+          end
+
+          def self.negate
+            # The negation of an `UnboundedSetWithExclusions` is still an `UnboundedSetWithExclusions`. While it would flip
+            # which values are in or out of the set, this object is still the representation in our data model for that case.
+            self
+          end
+        end
+
+        private_constant :UnboundedSetWithExclusions
       end
     end
   end

data/lib/elastic_graph/graphql/http_endpoint.rb

@@ -197,7 +197,7 @@ module ElasticGraph
       end
 
       def content_type
-        @content_type ||= normalized_headers["CONTENT-TYPE"]
+        normalized_headers["CONTENT-TYPE"]
       end
 
       def self.normalize_header_name(header)

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

@@ -96,12 +96,18 @@ module ElasticGraph
         # on `filter_value_set_extractor` to determine it, since it understands the semantics
         # of `any_of`, `not`, etc.
         def can_match_nil_values_at?(path, filter)
-          filter_value_set_extractor.extract_filter_value_set([filter], [path]).includes_nil?
+          value_set = filter_value_set_extractor.extract_filter_value_set([filter], [path])
+          (_ = value_set).nil? || value_set.includes_nil?
         end
 
         def filter_value_set_extractor
           @filter_value_set_extractor ||=
-            Filtering::FilterValueSetExtractor.new(schema_element_names, IncludesNilSet, ExcludesNilSet) do |operator, filter_value|
+            Filtering::FilterValueSetExtractor.new(
+              filter_node_interpreter,
+              schema_element_names,
+              IncludesNilSet,
+              ExcludesNilSet
+            ) do |operator, filter_value|
               if operator == :equal_to_any_of && filter_value.include?(nil)
                 IncludesNilSet
               else

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

@@ -25,7 +25,7 @@ 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[q] }
+          queries.map { |q| responses_by_query.fetch(q) }
         end
 
         def self.execute_many(queries, for_context:)

data/lib/elastic_graph/graphql.rb

@@ -129,9 +129,10 @@ module ElasticGraph
       @datastore_query_builder ||= begin
         require "elastic_graph/graphql/datastore_query"
         DatastoreQuery::Builder.with(
-          filter_interpreter: filter_interpreter,
-          runtime_metadata: runtime_metadata,
-          logger: logger,
+          filter_interpreter:,
+          filter_node_interpreter:,
+          runtime_metadata:,
+          logger:,
           default_page_size: @config.default_page_size,
           max_page_size: @config.max_page_size
         )

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: elasticgraph-graphql
 version: !ruby/object:Gem::Version
-  version: 0.19.0.0.rc1
+  version: 0.19.0.0
 platform: ruby
 authors:
 - Myron Marston
 - Ben VandenBos
 - Block Engineering
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-12-03 00:00:00.000000000 Z
+date: 2024-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop-factory_bot
@@ -74,14 +74,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: 1.9.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: 1.9.0
 - !ruby/object:Gem::Dependency
   name: coderay
   requirement: !ruby/object:Gem::Requirement
@@ -268,113 +268,113 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.0.0.rc1
+        version: 0.19.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.0.0.rc1
+        version: 0.19.0.0
 - !ruby/object:Gem::Dependency
   name: elasticgraph-schema_artifacts
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.0.0.rc1
+        version: 0.19.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.0.0.rc1
+        version: 0.19.0.0
 - !ruby/object:Gem::Dependency
   name: graphql
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.4.5
+        version: 2.4.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.4.5
+        version: 2.4.8
 - !ruby/object:Gem::Dependency
   name: elasticgraph-admin
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.0.0.rc1
+        version: 0.19.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.0.0.rc1
+        version: 0.19.0.0
 - !ruby/object:Gem::Dependency
   name: elasticgraph-elasticsearch
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.0.0.rc1
+        version: 0.19.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.0.0.rc1
+        version: 0.19.0.0
 - !ruby/object:Gem::Dependency
   name: elasticgraph-opensearch
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.0.0.rc1
+        version: 0.19.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.0.0.rc1
+        version: 0.19.0.0
 - !ruby/object:Gem::Dependency
   name: elasticgraph-indexer
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.0.0.rc1
+        version: 0.19.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.0.0.rc1
+        version: 0.19.0.0
 - !ruby/object:Gem::Dependency
   name: elasticgraph-schema_definition
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.0.0.rc1
+        version: 0.19.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.19.0.0.rc1
-description: 
+        version: 0.19.0.0
+description:
 email:
 - myron@squareup.com
 executables: []
@@ -466,12 +466,12 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/block/elasticgraph/issues
-  changelog_uri: https://github.com/block/elasticgraph/releases/tag/v0.19.0.0.rc1
+  changelog_uri: https://github.com/block/elasticgraph/releases/tag/v0.19.0.0
   documentation_uri: https://block.github.io/elasticgraph/docs/main/
   homepage_uri: https://block.github.io/elasticgraph/
-  source_code_uri: https://github.com/block/elasticgraph/tree/v0.19.0.0.rc1/elasticgraph-graphql
+  source_code_uri: https://github.com/block/elasticgraph/tree/v0.19.0.0/elasticgraph-graphql
   gem_category: core
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -486,8 +486,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: The ElasticGraph GraphQL query engine.
 test_files: []