elasticgraph-graphql 0.18.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b19df00bc750f39aa2cbccab58af18c6cb2a2329017e9d0aa8f889dce5b1c377
+  data.tar.gz: 8308fce167bd7cf625bb7b82f2f717c174ffa12655b1df77e58e37369b8d6294
+SHA512:
+  metadata.gz: c983f82a5da8da47c2f8146337b9425623d1ebfacf0e2f93db706cd53e465725f12cc43fe4e49d2b7885422a428e7744ae61642264941d3d497eb4d4fd3bc9f6
+  data.tar.gz: 277958b0fee144f62342f2e3081f4ebbb9a7529456e62a2b5183ad8fe93f2cca7fd5013cbe9bf461fceee46d5f42cea8149d40b624410fbb9498267e78d1dedb

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Block, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,3 @@
+# ElasticGraph::GraphQL
+
+Provides the ElasticGraph GraphQL query engine.

data/elasticgraph-graphql.gemspec

@@ -0,0 +1,23 @@
+# Copyright 2024 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require_relative "../gemspec_helper"
+
+ElasticGraphGemspecHelper.define_elasticgraph_gem(gemspec_file: __FILE__, category: :core) do |spec, eg_version|
+  spec.summary = "The ElasticGraph GraphQL query engine."
+
+  spec.add_dependency "elasticgraph-datastore_core", eg_version
+  spec.add_dependency "elasticgraph-schema_artifacts", eg_version
+  spec.add_dependency "graphql", ">= 2.3.7", "< 2.4"
+
+  spec.add_development_dependency "elasticgraph-admin", eg_version
+  spec.add_development_dependency "elasticgraph-elasticsearch", eg_version
+  spec.add_development_dependency "elasticgraph-opensearch", eg_version
+  spec.add_development_dependency "elasticgraph-indexer", eg_version
+  spec.add_development_dependency "elasticgraph-schema_definition", eg_version
+end

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

@@ -0,0 +1,79 @@
+# Copyright 2024 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+module ElasticGraph
+  class GraphQL
+    module Aggregation
+      # Grouping adapter that uses a `composite` aggregation.
+      #
+      # For now, only used for the outermost "root" aggregations but may be used for sub-aggregations in the future.
+      module CompositeGroupingAdapter
+        class << self
+          def meta_name
+            "comp"
+          end
+
+          def grouping_detail_for(query)
+            sources = build_sources(query)
+
+            inner_clauses = yield
+            inner_clauses = nil if inner_clauses.empty?
+
+            return AggregationDetail.new(inner_clauses, {}) if sources.empty?
+
+            clauses = {
+              query.name => {
+                "composite" => {
+                  "size" => query.paginator.requested_page_size,
+                  "sources" => sources,
+                  "after" => composite_after(query)
+                }.compact,
+                "aggs" => inner_clauses
+              }.compact
+            }
+
+            AggregationDetail.new(clauses, {"buckets_path" => [query.name]})
+          end
+
+          def prepare_response_buckets(sub_agg, buckets_path, meta)
+            sub_agg.dig(*buckets_path).fetch("buckets").map do |bucket|
+              bucket.merge({"doc_count_error_upper_bound" => 0})
+            end
+          end
+
+          private
+
+          def composite_after(query)
+            return unless (cursor = query.paginator.search_after)
+            expected_keys = query.groupings.map(&:key)
+
+            if cursor.sort_values.keys.sort == expected_keys.sort
+              cursor.sort_values
+            else
+              raise ::GraphQL::ExecutionError, "`#{cursor.encode}` is not a valid cursor for the current groupings."
+            end
+          end
+
+          def build_sources(query)
+            # We don't want documents that have no value for a grouping field to be omitted, so we set `missing_bucket: true`.
+            # https://www.elastic.co/guide/en/elasticsearch/reference/8.11/search-aggregations-bucket-composite-aggregation.html#_missing_bucket
+            grouping_options = if query.paginator.search_in_reverse?
+              {"order" => "desc", "missing_bucket" => true}
+            else
+              {"missing_bucket" => true}
+            end
+
+            query.groupings.map do |grouping|
+              {grouping.key => grouping.composite_clause(grouping_options: grouping_options)}
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# Copyright 2024 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/graphql/aggregation/key"
+require "elastic_graph/graphql/aggregation/field_path_encoder"
+
+module ElasticGraph
+  class GraphQL
+    module Aggregation
+      # Represents some sort of aggregation computation (min, max, avg, sum, etc) on a field.
+      # For the relevant Elasticsearch docs, see:
+      # https://www.elastic.co/guide/en/elasticsearch/reference/7.12/search-aggregations-metrics-avg-aggregation.html
+      # https://www.elastic.co/guide/en/elasticsearch/reference/7.12/search-aggregations-metrics-max-aggregation.html
+      # https://www.elastic.co/guide/en/elasticsearch/reference/7.12/search-aggregations-metrics-min-aggregation.html
+      # https://www.elastic.co/guide/en/elasticsearch/reference/7.12/search-aggregations-metrics-sum-aggregation.html
+      Computation = ::Data.define(:source_field_path, :computed_index_field_name, :detail) do
+        # @implements Computation
+
+        def key(aggregation_name:)
+          Key::AggregatedValue.new(
+            aggregation_name: aggregation_name,
+            field_path: source_field_path.map(&:name_in_graphql_query),
+            function_name: computed_index_field_name
+          ).encode
+        end
+
+        def clause
+          encoded_path = FieldPathEncoder.join(source_field_path.filter_map(&:name_in_index))
+          {detail.function.to_s => {"field" => encoded_path}}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# Copyright 2024 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/constants"
+require "elastic_graph/graphql/aggregation/field_path_encoder"
+require "elastic_graph/support/memoizable_data"
+
+module ElasticGraph
+  class GraphQL
+    module Aggregation
+      # Represents a grouping of a timestamp field into a date histogram.
+      # For the relevant Elasticsearch docs, see:
+      # https://www.elastic.co/guide/en/elasticsearch/reference/7.12/search-aggregations-bucket-datehistogram-aggregation.html
+      # https://www.elastic.co/guide/en/elasticsearch/reference/7.12/search-aggregations-bucket-composite-aggregation.html#_date_histogram
+      class DateHistogramGrouping < Support::MemoizableData.define(:field_path, :interval, :time_zone, :offset)
+        def key
+          @key ||= FieldPathEncoder.encode(field_path.map(&:name_in_graphql_query))
+        end
+
+        def encoded_index_field_path
+          @encoded_index_field_path ||= FieldPathEncoder.join(field_path.filter_map(&:name_in_index))
+        end
+
+        def composite_clause(grouping_options: {})
+          interval_options = INTERVAL_OPTIONS_BY_NAME.fetch(interval) do
+            raise ArgumentError, "#{interval.inspect} is an unsupported interval. Valid values: #{INTERVAL_OPTIONS_BY_NAME.keys.inspect}."
+          end
+
+          inner_hash = interval_options.merge(grouping_options).merge({
+            "field" => encoded_index_field_path,
+            "format" => DATASTORE_DATE_TIME_FORMAT,
+            "offset" => offset,
+            "time_zone" => time_zone
+          }.compact)
+
+          {"date_histogram" => inner_hash}
+        end
+
+        def non_composite_clause_for(query)
+          # `min_doc_count: 1` is important so we don't have excess buckets when there is a large gap
+          # between document dates. For example, if you group on a field at the year truncation unit, and
+          # a one-off rogue document has an incorrect timestamp for hundreds of years ago, you'll wind
+          # up with a bucket for each intervening year. `min_doc_count: 1` excludes those empty buckets.
+          composite_clause(grouping_options: {"min_doc_count" => 1})
+        end
+
+        def inner_meta
+          INNER_META
+        end
+
+        INNER_META = {
+          # On a date histogram aggregation, the `key` is formatted as a number (milliseconds since epoch). We
+          # need it formatted as a string, which `key_as_string` provides.
+          "key_path" => ["key_as_string"],
+          # Date histogram aggregations do not have any doc count error. Our resolver is generic and expects
+          # there to always be a `doc_count_error_upper_bound`. So we want to tell it to merge an error of `0`
+          # into each bucket.
+          "merge_into_bucket" => {"doc_count_error_upper_bound" => 0}
+        }
+
+        INTERVAL_OPTIONS_BY_NAME = {
+          # These intervals have only fixed intervals...
+          "millisecond" => {"fixed_interval" => "1ms"},
+          "second" => {"fixed_interval" => "1s"},
+          # ...but the rest have calendar intervals, which we prefer.
+          "minute" => {"calendar_interval" => "minute"},
+          "hour" => {"calendar_interval" => "hour"},
+          "day" => {"calendar_interval" => "day"},
+          "week" => {"calendar_interval" => "week"},
+          "month" => {"calendar_interval" => "month"},
+          "quarter" => {"calendar_interval" => "quarter"},
+          "year" => {"calendar_interval" => "year"}
+        }
+        private_constant :INTERVAL_OPTIONS_BY_NAME
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# Copyright 2024 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/error"
+
+module ElasticGraph
+  class GraphQL
+    module Aggregation
+      module FieldPathEncoder
+        # Embedded fields need to be specified with dot separators.
+        DELIMITER = "."
+
+        # Takes a list of field names (e.g., ["amountMoney", "amount"])
+        # and returns a single field name path string (e.g., "amountMoney.amount").
+        def self.encode(field_names)
+          field_names.each do |str|
+            verify_delimiters(str)
+          end
+
+          join(field_names)
+        end
+
+        # Joins together a list of encoded paths.
+        def self.join(encoded_paths)
+          encoded_paths.join(DELIMITER)
+        end
+
+        # Takes a field path (e.g., "amountMoney.amount") and returns the field name parts
+        # (["amountMoney", "amount"]).
+        def self.decode(field_path)
+          field_path.split(DELIMITER)
+        end
+
+        private_class_method def self.verify_delimiters(str)
+          if str.to_s.include?(DELIMITER)
+            raise InvalidArgumentValueError, %("#{str}" contains delimiter: "#{DELIMITER}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# Copyright 2024 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/graphql/aggregation/term_grouping"
+
+module ElasticGraph
+  class GraphQL
+    module Aggregation
+      class FieldTermGrouping < Support::MemoizableData.define(:field_path)
+        # @dynamic field_path
+        include TermGrouping
+
+        private
+
+        def terms_subclause
+          {"field" => encoded_index_field_path}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# Copyright 2024 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/error"
+require "elastic_graph/graphql/aggregation/field_path_encoder"
+
+module ElasticGraph
+  class GraphQL
+    module Aggregation
+      module Key
+        # The datastore only gives us an "aggregation key" (or name) to tie response values back to the part of
+        # request it came from. We use this delimiter to encode and decode aggregation keys.
+        DELIMITER = ":"
+
+        # Aggregation key implementation used when we're dealing with `aggregated_values`.
+        class AggregatedValue < ::Data.define(
+          # The name of the aggregation encoded into this key.
+          :aggregation_name,
+          # The path to the field used by this aggregation (encoded as a string)
+          :encoded_field_path,
+          # The name of the aggregation function, such as "sum".
+          :function_name
+        )
+          # We encode the field path as part of initialization to enforce an invariant that all `AggregatedValue`
+          # instances have valid values for all attributes. `FieldPathEncoder.encode` will raise an exception if
+          # the field path is invalid.
+          def initialize(aggregation_name:, function_name:, field_path: [], encoded_field_path: FieldPathEncoder.encode(field_path))
+            Key.verify_no_delimiter_in(aggregation_name, function_name, *field_path)
+
+            super(
+              aggregation_name: aggregation_name,
+              encoded_field_path: encoded_field_path,
+              function_name: function_name
+            )
+          end
+
+          def encode
+            Key.encode([aggregation_name, encoded_field_path, function_name])
+          end
+
+          def field_path
+            FieldPathEncoder.decode(encoded_field_path)
+          end
+        end
+
+        # Encodes the key used for a `missing` aggregation used to provide a bucket for
+        # documents that are missing a value for the field being grouped on.
+        def self.missing_value_bucket_key(base_key)
+          Key.encode([base_key, "m"])
+        end
+
+        # Extracts an aggregation name from a string that could either already be an aggregation name, or could
+        # be an encoded key. We need this for dealing with the multiple forms that aggregation responses take:
+        #
+        # - When we use `grouped_by`, we run a composite aggregation that has the aggregation name, and
+        #   that shows up as a key directly under `aggregations` in the datastore response.
+        # - For aggregations with no `grouped_by`, we encode the aggregation name in the key, and the keys
+        #   directly under `aggregations` in the datastore response will take a from like:
+        #   `[agg_name]:[field_path]:[function]`.
+        #
+        # It's also possible for these two forms to be mixed under `aggregations` on a datastore response,
+        # where some hash keys are in one form and some are in the other form. This can happen when we run
+        # multiple aggregations (some with `grouped_by`, some without) in the same query.
+        def self.extract_aggregation_name_from(agg_name_or_key)
+          agg_name_or_key.split(DELIMITER, 2).first || agg_name_or_key
+        end
+
+        def self.encode(parts)
+          parts.join(DELIMITER)
+        end
+
+        def self.verify_no_delimiter_in(*parts)
+          parts.each do |part|
+            if part.to_s.include?(DELIMITER)
+              raise InvalidArgumentValueError, %("#{part}" contains delimiter: "#{DELIMITER}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# Copyright 2024 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/graphql/aggregation/field_path_encoder"
+
+module ElasticGraph
+  class GraphQL
+    module Aggregation
+      # Represents a sub-aggregation on a `nested` field.
+      # For the relevant Elasticsearch docs, see:
+      # https://www.elastic.co/guide/en/elasticsearch/reference/8.10/search-aggregations-bucket-nested-aggregation.html
+      class NestedSubAggregation < ::Data.define(:nested_path, :query)
+        def build_agg_hash(filter_interpreter, parent_queries:)
+          detail = query.build_agg_detail(filter_interpreter, field_path: nested_path, parent_queries: parent_queries)
+          return {} if detail.nil?
+
+          query_names = parent_queries.map(&:name) + [query.name]
+          {
+            Key.encode(query_names) => {
+              "nested" => {"path" => FieldPathEncoder.encode(nested_path.filter_map(&:name_in_index))},
+              "aggs" => detail.clauses,
+              "meta" => detail.meta.merge({
+                "size" => query.paginator.desired_page_size,
+                "adapter" => query.grouping_adapter.meta_name
+              })
+            }.compact
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# Copyright 2024 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+module ElasticGraph
+  class GraphQL
+    module Aggregation
+      # Grouping adapter that avoids using a `composite` aggregation, due to limitations with Elasticsearch/OpenSearch.
+      module NonCompositeGroupingAdapter
+        class << self
+          def meta_name
+            "non_comp"
+          end
+
+          def grouping_detail_for(query)
+            date_groupings, term_groupings = query.groupings.partition do |grouping|
+              grouping.is_a?(DateHistogramGrouping)
+            end
+
+            grouping_detail(date_groupings, query) do
+              # We want term groupings inside date groupings so that, when our bucket aggregations might produce
+              # inaccurate doc counts, the innermost grouping aggregation has `doc_count_error_upper_bound` on
+              # its buckets allowing us to expose information about the accuracy.
+              #
+              # Date histogram aggregations do not include `doc_count_error_upper_bound` because, on their own, they are
+              # always accurate, but they may not be accurate when used as a sub-aggregation of a `terms` aggregation.
+              #
+              # For more detail on the issue this ordering is designed to avoid, see:
+              # https://discuss.elastic.co/t/accuracy-of-date-histogram-sub-aggregation-doc-count-under-terms-aggregation/348685
+              grouping_detail(term_groupings, query) do
+                inner_clauses = yield
+                inner_clauses = nil if inner_clauses.empty?
+                AggregationDetail.new(inner_clauses, {})
+              end
+            end
+          end
+
+          def prepare_response_buckets(sub_agg, buckets_path, meta)
+            sort_and_truncate_buckets(format_buckets(sub_agg, buckets_path), meta.fetch("size"))
+          end
+
+          private
+
+          def grouping_detail(groupings, query)
+            # Our `reduce` here builds the date grouping clauses from the inside out (since each reduction step
+            # wraps the prior step's result in an outer `aggs` hash). The natural result of that is a nested set of
+            # date grouping clauses that "feels" inside-out compared to what you would naturally expect.
+            #
+            # While that causes no concrete issue, it's nice to avoid. Here we use `reverse` to correct for that.
+            groupings.reverse.reduce(yield) do |inner_detail, grouping|
+              inner_detail.wrap_with_grouping(grouping, query: query)
+            end
+          end
+
+          # Formats the result of a bucket aggregation into a format that we can easily resolve. There are two things
+          # this accomplishes:
+          #
+          # - Converts bucket keys into hashes that can be used to resolve `grouped_by` fields.
+          # - Recursively flattens multiple levels of aggregations (which happens when we need to mix multiple kinds of
+          #   bucket aggregations to group in the way the client requested) into a single flat list.
+          def format_buckets(sub_agg, buckets_path, parent_key_fields: {}, parent_key_values: [])
+            agg_with_buckets = sub_agg.dig(*buckets_path)
+
+            missing_bucket = {
+              # Doc counts in missing value buckets are always perfectly accurate.
+              "doc_count_error_upper_bound" => 0
+            }.merge(sub_agg.dig(*missing_bucket_path_from(buckets_path))) # : ::Hash[::String, untyped]
+
+            meta = agg_with_buckets.fetch("meta")
+
+            grouping_field_names = meta.fetch("grouping_fields") # provides the names of the fields being grouped on
+            key_path = meta.fetch("key_path") # indicates whether we want to get the key values from `key` or `key_as_string`.
+            sub_buckets_path = meta["buckets_path"] # buckets_path is optional, so we don't use fetch.
+            merge_into_bucket = meta.fetch("merge_into_bucket")
+
+            raw_buckets = agg_with_buckets.fetch("buckets") # : ::Array[::Hash[::String, untyped]]
+
+            # If the missing bucket is non-empty, include it. This matches the behavior of composite aggregations
+            # when the `missing_bucket` option is used.
+            raw_buckets += [missing_bucket] if missing_bucket.fetch("doc_count") > 0
+
+            raw_buckets.flat_map do |raw_bucket|
+              # The key will either be a single value (e.g. `47`) if we used a `terms`/`date_histogram` aggregation,
+              # or a tuple of values (e.g. `[47, "abc"]`) if we used a `multi_terms` aggregation. Here we convert it
+              # to the form needed for resolving `grouped_by` fields: a hash like `{"size" => 47, "tag" => "abc"}`.
+              key_values = Array(raw_bucket.dig(*key_path))
+              key_fields_hash = grouping_field_names.zip(key_values).to_h
+
+              # If we have multiple levels of aggregations, we need to merge the key fields hash with the key fields from the parent levels.
+              key_fields = parent_key_fields.merge(key_fields_hash)
+              key_values = parent_key_values + key_values
+
+              # If there's another level of aggregations, `buckets_path` will provide us with the path to that next level.
+              # We can use it to recurse as we build a flat list of buckets.
+              if sub_buckets_path
+                format_buckets(raw_bucket, sub_buckets_path, parent_key_fields: key_fields, parent_key_values: key_values)
+              else
+                [raw_bucket.merge(merge_into_bucket).merge({"key" => key_fields, "key_values" => key_values})]
+              end
+            end
+          end
+
+          # A `terms` or `multi_terms` sub-aggregation is automatically sorted by `doc_count` and we pass
+          # `size` to the datastore to limit the number of returned buckets.
+          #
+          # A `date_histogram` sub-aggregation is sorted ascending by the date, and we don't limit the buckets
+          # in any way (there's no `size` parameter).
+          #
+          # To honor the requested page size and return buckets in a consistent order, we sort the buckets here
+          # (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)
+          end
+
+          def missing_bucket_path_from(buckets_path)
+            *all_but_last, last = buckets_path
+            all_but_last + [Key.missing_value_bucket_key(last.to_s)]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# Copyright 2024 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+module ElasticGraph
+  class GraphQL
+    module Aggregation
+      PathSegment = ::Data.define(
+        # The name of this segment's field in the GraphQL query. If it's an aliased field, this
+        # will be the alias name.
+        :name_in_graphql_query,
+        # The name of this segment's field in the datastore index.
+        :name_in_index
+      ) do
+        # Factory method that aids in building a `PathSegment` for a given `field` and `lookahead` node.
+        def self.for(lookahead:, field: nil)
+          ast_node = lookahead.ast_nodes.first # : ::GraphQL::Language::Nodes::Field
+
+          new(
+            name_in_graphql_query: ast_node.alias || ast_node.name,
+            name_in_index: field&.name_in_index&.to_s
+          )
+        end
+      end
+    end
+  end
+end