elasticgraph-graphql 0.18.0.5 → 0.19.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53e5c759fafb5fe181ae65912c42b21d6d6dbe8cbd3558962cb5a56bc94944b6
-  data.tar.gz: 862a18dd839b8ee841b91430eb7188612c5483c5701930cf23cfbb22ce44e876
+  metadata.gz: c907a36c44ef987d02202ff39ef9686c3bfc997ce80d9310da0e3364d89de5d0
+  data.tar.gz: 1a2f992e201097a980b5fa4f16f9721f8f51d2888dc8d12f3267101765b3c7af
 SHA512:
-  metadata.gz: 4739bc5c2978a75528777b58073ba9e606a5964ff1adcfbb1b19c77eb43e29c5bb19e5aa137d2b530bd2937ca5499538149959b23cf55a7912f9b04b50809e3f
-  data.tar.gz: fb6b7226810f2f58bd7aedca80a9e1be097ffbbc8dbb5532805f9d98392006e2c4f0db7344c64250c3bd6adcdb917972e230324cc876c0639bba3a40d0601067
+  metadata.gz: baba491d690547b7722d7b715af442b691c341abb0c29a25da6678e068d3199a7765829acd8121b756ee464685c7dba92b9beb0f2f34d2431b20e1e1783e347d
+  data.tar.gz: 289be9c156185ff45b152a504fd6b72f61cba8982b61acf8373e18cf5bc10a70f9978db2c99040bdde0b4824d811b58b812290e3fc08b809940bf998b975022e

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.3.14"
+  spec.add_dependency "graphql", "~> 2.4.5"
 
   spec.add_development_dependency "elasticgraph-admin", eg_version
   spec.add_development_dependency "elasticgraph-elasticsearch", eg_version

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

@@ -114,8 +114,17 @@ module ElasticGraph
           # (by doc count descending, then by the key values ascending), and then take only first `size`.
           def sort_and_truncate_buckets(buckets, size)
             buckets
-              .sort_by { |b| [-b.fetch("doc_count"), b.fetch("key_values")] }
-              .first(size)
+              .sort_by do |b|
+                # We convert key values to strings to ensure they are comparable. Otherwise, we can get an error like:
+                #
+                # > ArgumentError: comparison of Array with Array failed
+                #
+                # Note that this turns it into a lexicographical sort rather than a more type-aware sort
+                # (10 will sort before 2, for example), but that's fine. We only sort by `key_values` as
+                # a time breaker to ensure deterministic results, but don't particularly care which buckets
+                # come first.
+                [-b.fetch("doc_count"), b.fetch("key_values").map(&:to_s)]
+              end.first(size)
           end
 
           def missing_bucket_path_from(buckets_path)

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

@@ -15,7 +15,7 @@ module ElasticGraph
       # 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) do |operator, filter_value|
+          @filter_value_set_extractor = Filtering::FilterValueSetExtractor.new(schema_names, Support::TimeSet::ALL, Support::TimeSet::EMPTY) do |operator, filter_value|
             case operator
             when :gt, :gte, :lt, :lte
               if date_string?(filter_value)

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

@@ -16,8 +16,9 @@ module ElasticGraph
         def initialize(schema_names:)
           # @type var all_values_set: _RoutingValueSet
           all_values_set = RoutingValueSet::ALL
+          empty_set = RoutingValueSet::EMPTY
 
-          @filter_value_set_extractor = Filtering::FilterValueSetExtractor.new(schema_names, all_values_set) do |operator, filter_value|
+          @filter_value_set_extractor = Filtering::FilterValueSetExtractor.new(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)
@@ -70,6 +71,7 @@ module ElasticGraph
         end
 
         ALL = of_all_except([])
+        EMPTY = of([])
 
         def intersection(other_set)
           # Here we return `self` to preserve the commutative property of `intersection`. Returning `self`

data/lib/elastic_graph/graphql/datastore_search_router.rb

@@ -61,7 +61,7 @@ module ElasticGraph
           # Unfortunately, the Elasticsearch/OpenSearch clients don't support setting a per-request client-side timeout,
           # even though Faraday (the underlying HTTP client) does. To work around this, we pass our desired
           # timeout in a specific header that the `SupportTimeouts` Faraday middleware will use.
-          headers = {TIMEOUT_MS_HEADER => msearch_request_timeout_from(queries)}.compact
+          headers = {TIMEOUT_MS_HEADER => msearch_request_timeout_from(queries)&.to_s}.compact
 
           queries_and_header_body_tuples_by_datastore_client = header_body_tuples_by_query.group_by do |(query, header_body_tuples)|
             @datastore_clients_by_name.fetch(query.cluster_name)
@@ -118,6 +118,8 @@ module ElasticGraph
         return if failures.empty?
 
         formatted_failures = failures.map do |(query, response), index|
+          raise_execution_exception_for_known_public_error(response)
+
           # Note: we intentionally omit the body of the request here, because it could contain PII
           # or other sensitive values that we don't want logged.
           <<~ERROR
@@ -130,6 +132,21 @@ module ElasticGraph
         raise Errors::SearchFailedError, "Got #{failures.size} search failure(s):\n\n#{formatted_failures}"
       end
 
+      # In general, when we receive a datastore response indicating a search failed, we raise
+      # `Errors::SearchFailedError` which translates into a `500 Internal Server Error`. That's
+      # appropriate for transient errors (particularly when there's nothing the client can do about
+      # it) but for non-transient errors that the client can do something about, we'd like to provide
+      # a friendlier error. This method handles those cases.
+      #
+      # GraphQL::ExecutionError is automatically translated into a nice error response.
+      def raise_execution_exception_for_known_public_error(response)
+        if response.dig("error", "caused_by", "type") == "too_many_buckets_exception"
+          max_buckets = response.dig("error", "caused_by", "max_buckets")
+          raise ::GraphQL::ExecutionError, "Aggregation query produces too many groupings. " \
+            "Reduce the grouping cardinality to less than #{max_buckets} and try again."
+        end
+      end
+
       # Examine successful query responses and log any shard failure they encounter
       def log_shard_failure_if_necessary(responses_by_query)
         shard_failures = responses_by_query.each_with_index.select do |(query, response), query_numeric_index|

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

@@ -33,12 +33,7 @@ module ElasticGraph
           bool_node[occurrence].concat(clauses)
         end
 
-        # For `any_of: []` we need a way to force the datastore to match no documents, but
-        # I haven't found any sort of literal `false` we can pass in the compound expression
-        # or even a literal `1 = 0` as is sometimes used in SQL. Instead, we use this for that
-        # case.
-        empty_array = [] # : ::Array[untyped]
-        ALWAYS_FALSE_FILTER = filter({ids: {values: empty_array}})
+        ALWAYS_FALSE_FILTER = filter({match_none: {}})
       end
     end
   end

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

@@ -59,14 +59,9 @@ module ElasticGraph
 
         def process_filter_hash(bool_node, filter_hash, field_path)
           filter_hash.each do |field_or_op, expression|
-            # `nil` filter predicates should be ignored, so we can safely `compact` them out.
-            # It also is simpler to handle them once here instead of the different branches
-            # below having to be aware of possible `nil` predicates.
-            expression = expression.compact if expression.is_a?(::Hash)
-
             case filter_node_interpreter.identify_node_type(field_or_op, expression)
             when :empty
-              # This is an "empty" filter predicate and we can ignore it.
+              # This is an "empty" filter predicate and can be treated as `true`.
             when :not
               process_not_expression(bool_node, expression, field_path)
             when :list_any_filter
@@ -109,10 +104,14 @@ module ElasticGraph
 
         def process_not_expression(bool_node, expression, field_path)
           sub_filter = build_bool_hash do |inner_node|
-            process_filter_hash(inner_node, expression, field_path)
+            process_filter_hash(inner_node, expression || {}, field_path)
           end
 
-          return unless sub_filter
+          unless sub_filter
+            # Since an empty expression is treated as `true`, convert to `false` when negating.
+            BooleanQuery::ALWAYS_FALSE_FILTER.merge_into(bool_node)
+            return
+          end
 
           # Prevent any negated filters from being unnecessarily double-negated by
           # converting them to a positive filter (i.e., !!A == A).
@@ -138,6 +137,8 @@ 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
@@ -188,22 +189,37 @@ module ElasticGraph
           end
         end
 
+        # We want to provide the following semantics for `any_of`:
+        #
+        # * `filter: {anyOf: []}` -> return no results
+        # * `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
+            # `should`. To get the behavior we want, we need to pass the datastore some filter criteria
+            # that will evaluate to false for every document.
+            BooleanQuery::ALWAYS_FALSE_FILTER.merge_into(bool_node)
+            return
+          end
+
           shoulds = expressions.filter_map do |expression|
             build_bool_hash do |inner_bool_node|
               process_filter_hash(inner_bool_node, expression, field_path)
             end
           end
 
-          # When our `shoulds` array is empty, the filtering semantics we want is 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 `should`. To get the behavior we want, we need to pass the datastore some filter
-          # criteria that will evaluate to false for every document.
-          bool_query = shoulds.empty? ? BooleanQuery::ALWAYS_FALSE_FILTER : BooleanQuery.should(*shoulds)
-          bool_query.merge_into(bool_node)
+          return if shoulds.size < expressions.size
+
+          BooleanQuery.should(*shoulds).merge_into(bool_node)
         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|
@@ -212,6 +228,8 @@ 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).
@@ -299,6 +317,8 @@ 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:
           #
@@ -313,7 +333,7 @@ module ElasticGraph
           # While we index an explicit count of 0, the count field will be missing from documents indexed before
           # the list field was defined on the ElasticGraph schema. To properly match those documents, we need to
           # convert this into an OR (using `any_of`) to also match documents that lack the field entirely.
-          unless excludes_zero?(expression)
+          if filters_to_range_including_zero?(expression)
             expression = {schema_names.any_of => [
               expression,
               {schema_names.equal_to_any_of => [nil]}
@@ -326,7 +346,7 @@ module ElasticGraph
         def build_bool_hash(&block)
           bool_node = Hash.new { |h, k| h[k] = [] }.tap(&block)
 
-          # To ignore "empty" filter predicates we need to return `nil` here.
+          # To treat "empty" filter predicates as `true` we need to return `nil` here.
           return nil if bool_node.empty?
 
           # According to https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-bool-query.html#bool-min-should-match,
@@ -337,20 +357,28 @@ module ElasticGraph
           {bool: bool_node}
         end
 
-        # Determines if the given filter expression excludes the value `0`.
-        def excludes_zero?(expression)
-          expression.any? do |operator, operand|
-            case operator
-            when schema_names.equal_to_any_of then !operand.include?(0)
-            when schema_names.lt then operand <= 0
-            when schema_names.lte then operand < 0
-            when schema_names.gt then operand >= 0
-            when schema_names.gte then operand > 0
-            else
-              # :nocov: -- all operators are covered above. But simplecov complains about an implicit `else` branch being uncovered, so here we've defined it to wrap it with `:nocov:`.
-              false
-              # :nocov:
-            end
+        # Determines if the given expression filters to a range that includes `0`.
+        # If it does not do any filtering (e.g. an empty expression) it will return `false`.
+        def filters_to_range_including_zero?(expression)
+          expression = expression.compact
+
+          expression.size > 0 && expression.none? do |operator, operand|
+            operator_excludes_zero?(operator, operand)
+          end
+        end
+
+        # Determines if the given operator and operand exclude 0 as a matched value.
+        def operator_excludes_zero?(operator, operand)
+          case operator
+          when schema_names.equal_to_any_of then !operand.include?(0)
+          when schema_names.lt then operand <= 0
+          when schema_names.lte then operand < 0
+          when schema_names.gt then operand >= 0
+          when schema_names.gte then operand > 0
+          else
+            # :nocov: -- all operators are covered above. But simplecov complains about an implicit `else` branch being uncovered, so here we've defined it to wrap it with `:nocov:`.
+            false
+            # :nocov:
           end
         end
 

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

@@ -25,22 +25,32 @@ module ElasticGraph
         end
 
         def identify_node_type(field_or_op, sub_expression)
-          return :empty if sub_expression.nil? || 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
+
+        private
+
+        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)
-          :unknown
-        end
 
-        def filter_operators
-          @filter_operators ||= build_filter_operators(runtime_metadata)
+          nil
         end
 
-        private
+        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
+        end
 
         def build_filter_operators(runtime_metadata)
           filter_by_time_of_day_script_id = runtime_metadata

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

@@ -12,9 +12,10 @@ 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, &build_set_for_filter)
+        def initialize(schema_names, all_values_set, empty_set, &build_set_for_filter)
           @schema_names = schema_names
           @all_values_set = all_values_set
+          @empty_set = empty_set
           @build_set_for_filter = build_set_for_filter
         end
 
@@ -55,7 +56,7 @@ module ElasticGraph
           # outside the `map_reduce_sets` block below so we only do it once instead of N times.
           target_field_path_parts = target_field_path.split(".")
 
-          # Here we intersect the filter value setbecause when we have multiple `filter_hashes`,
+          # Here we intersect the filter value set, because when we have multiple `filter_hashes`,
           # the filters are ANDed together. Only documents that match ALL the filters will be
           # returned. Therefore, we want the intersection of filter value sets.
           map_reduce_sets(filter_hashes, :intersection, negate: false) do |filter_hash|
@@ -83,7 +84,7 @@ module ElasticGraph
         # 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 ignored by our filtering logic, so we need
+            # Any filter with a `nil` value 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
@@ -105,6 +106,11 @@ module ElasticGraph
 
         # Determines the set of filter values for an `any_of` clause, which is used for ORing multiple filters together.
         def filter_value_set_for_any_of(filter_hashes, target_field_path_parts, traversed_field_path_parts, negate:)
+          # Here we treat `any_of: []` as matching no values.
+          if filter_hashes.empty?
+            return negate ? @all_values_set : @empty_set
+          end
+
           # Here we union the filter value sets because `any_of` represents an OR. If we can determine specific
           # filter values for all `any_of` clauses, we will OR them together. Alternately, if we cannot
           # determine specific filter values for any clauses, we will union `@all_values_set`,

data/lib/elastic_graph/graphql/http_endpoint.rb

@@ -130,6 +130,10 @@ module ElasticGraph
         # Ignore an empty string operationName.
         params = params.merge("operationName" => nil) if params["operationName"] && params["operationName"].empty?
 
+        if (variables = params["variables"]) && !variables.is_a?(::Hash)
+          return HTTPResponse.error(400, "`variables` must be a JSON object but was not.")
+        end
+
         yield params
       end
 

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

@@ -101,7 +101,7 @@ module ElasticGraph
 
         def filter_value_set_extractor
           @filter_value_set_extractor ||=
-            Filtering::FilterValueSetExtractor.new(schema_element_names, IncludesNilSet) do |operator, filter_value|
+            Filtering::FilterValueSetExtractor.new(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

@@ -6,7 +6,7 @@
 #
 # frozen_string_literal: true
 
-require "graphql/dataloader/source"
+require "graphql"
 
 module ElasticGraph
   class GraphQL

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

@@ -23,7 +23,6 @@ module ElasticGraph
           Support::MemoizableData.define(:schema_element_names, *fields) do
             # @implements ResolvableValueClass
             include ResolvableValue
-            # @type var block: (^() -> void)?
             class_exec(&block) if block
           end
         end

data/lib/elastic_graph/graphql/schema.rb

@@ -29,7 +29,7 @@ module ElasticGraph
         scalar_types.to_set.union(introspection_types)
       )
 
-      attr_reader :element_names, :defined_types, :config, :graphql_schema, :runtime_metadata
+      attr_reader :element_names, :config, :graphql_schema, :runtime_metadata
 
       def initialize(
         graphql_schema_string:,
@@ -53,7 +53,6 @@ module ElasticGraph
           )
         end
 
-        @types_by_name = Hash.new { |hash, key| hash[key] = lookup_type_by_name(key) }
         @build_resolver = build_resolver
 
         # Note: as part of loading the schema, the GraphQL gem may use the resolver (such
@@ -68,7 +67,7 @@ module ElasticGraph
 
         # Pre-load all defined types so that all field extras can get configured as part
         # of loading the schema, before we execute the first query.
-        @defined_types = build_defined_types_array(@graphql_schema)
+        @types_by_name = build_types_by_name
       end
 
       def type_from(graphql_type)
@@ -80,7 +79,11 @@ module ElasticGraph
       # get type objects for wrapped types, but you need to get it from a field object of that
       # type.
       def type_named(type_name)
-        @types_by_name[type_name.to_s]
+        @types_by_name.fetch(type_name.to_s)
+      rescue KeyError => e
+        msg = "No type named #{type_name} could be found"
+        msg += "; Possible alternatives: [#{e.corrections.join(", ").delete('"')}]." if e.corrections.any?
+        raise Errors::NotFoundError, msg
       end
 
       def document_type_stored_in(index_definition_name)
@@ -106,6 +109,10 @@ module ElasticGraph
         @indexed_document_types ||= defined_types.select(&:indexed_document?)
       end
 
+      def defined_types
+        @defined_types ||= @types_by_name.except(*BUILT_IN_TYPE_NAMES).values
+      end
+
       def to_s
         "#<#{self.class.name} 0x#{__id__.to_s(16)} indexed_document_types=#{indexed_document_types.map(&:name).sort.to_s.delete(":")}>"
       end
@@ -128,24 +135,14 @@ module ElasticGraph
         def_delegators :resolver, :call, :resolve_type, :coerce_input, :coerce_result
       end
 
-      def lookup_type_by_name(type_name)
-        type_from(@graphql_schema.types.fetch(type_name))
-      rescue KeyError => e
-        msg = "No type named #{type_name} could be found"
-        msg += "; Possible alternatives: [#{e.corrections.join(", ").delete('"')}]." if e.corrections.any?
-        raise Errors::NotFoundError, msg
-      end
-
       def resolver
         @resolver ||= @build_resolver.call(self)
       end
 
-      def build_defined_types_array(graphql_schema)
-        graphql_schema
-          .types
-          .values
-          .reject { |t| BUILT_IN_TYPE_NAMES.include?(t.graphql_name) }
-          .map { |t| type_named(t.graphql_name) }
+      def build_types_by_name
+        graphql_schema.types.transform_values do |graphql_type|
+          @types_by_graphql_type[graphql_type]
+        end
       end
 
       def indexed_document_types_by_index_definition_name

data/lib/elastic_graph/graphql.rb

@@ -142,7 +142,13 @@ module ElasticGraph
     def graphql_gem_plugins
       @graphql_gem_plugins ||= begin
         require "graphql"
-        {::GraphQL::Dataloader => {}}
+        {
+          # We depend on this to avoid N+1 calls to the datastore.
+          ::GraphQL::Dataloader => {},
+          # This is new in the graphql-ruby 2.4 release, and will be required in the future.
+          # We pass `preload: true` because the way we handle the schema depends on it being preloaded.
+          ::GraphQL::Schema::Visibility => {preload: true}
+        }
       end
     end
 
@@ -244,6 +250,9 @@ module ElasticGraph
     # at boot time instead of deferring dependency loading until we handle the first query. In other environments (such as tests),
     # it's nice to load dependencies when needed.
     def load_dependencies_eagerly
+      require "graphql"
+      ::GraphQL.eager_load!
+
       # run a simple GraphQL query to force load any dependencies needed to handle GraphQL queries
       graphql_query_executor.execute(EAGER_LOAD_QUERY, client: Client::ELASTICGRAPH_INTERNAL)
       graphql_http_endpoint # force load this too.

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: elasticgraph-graphql
 version: !ruby/object:Gem::Version
-  version: 0.18.0.5
+  version: 0.19.0.0.rc2
 platform: ruby
 authors:
 - Myron Marston
 - Ben VandenBos
-- Square Engineering
+- Block Engineering
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-09-20 00:00:00.000000000 Z
+date: 2024-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop-factory_bot
@@ -46,42 +46,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: standard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.40.0
+        version: 1.41.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.40.0
+        version: 1.41.0
 - !ruby/object:Gem::Dependency
   name: steep
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: coderay
   requirement: !ruby/object:Gem::Requirement
@@ -136,14 +136,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.12'
+        version: '0.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.12'
+        version: '0.13'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -254,126 +254,126 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '3.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '3.5'
 - !ruby/object:Gem::Dependency
   name: elasticgraph-datastore_core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.5
+        version: 0.19.0.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.5
+        version: 0.19.0.0.rc2
 - !ruby/object:Gem::Dependency
   name: elasticgraph-schema_artifacts
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.5
+        version: 0.19.0.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.5
+        version: 0.19.0.0.rc2
 - !ruby/object:Gem::Dependency
   name: graphql
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.3.14
+        version: 2.4.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.3.14
+        version: 2.4.5
 - !ruby/object:Gem::Dependency
   name: elasticgraph-admin
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.5
+        version: 0.19.0.0.rc2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.5
+        version: 0.19.0.0.rc2
 - !ruby/object:Gem::Dependency
   name: elasticgraph-elasticsearch
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.5
+        version: 0.19.0.0.rc2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.5
+        version: 0.19.0.0.rc2
 - !ruby/object:Gem::Dependency
   name: elasticgraph-opensearch
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.5
+        version: 0.19.0.0.rc2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.5
+        version: 0.19.0.0.rc2
 - !ruby/object:Gem::Dependency
   name: elasticgraph-indexer
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.5
+        version: 0.19.0.0.rc2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.5
+        version: 0.19.0.0.rc2
 - !ruby/object:Gem::Dependency
   name: elasticgraph-schema_definition
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.5
+        version: 0.19.0.0.rc2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.0.5
+        version: 0.19.0.0.rc2
 description: 
 email:
 - myron@squareup.com
@@ -461,10 +461,15 @@ files:
 - lib/elastic_graph/graphql/schema/type.rb
 - script/dump_time_zones
 - script/dump_time_zones.java
-homepage: 
+homepage: https://block.github.io/elasticgraph/
 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.rc2
+  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.rc2/elasticgraph-graphql
   gem_category: core
 post_install_message: 
 rdoc_options: []