elasticgraph-graphql 0.19.1.1 → 0.19.2.0

data/lib/elastic_graph/graphql/query_executor.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at
@@ -18,12 +18,13 @@ module ElasticGraph
       # @dynamic schema
       attr_reader :schema
 
-      def initialize(schema:, monotonic_clock:, logger:, slow_query_threshold_ms:, datastore_search_router:)
+      def initialize(schema:, monotonic_clock:, logger:, slow_query_threshold_ms:, datastore_search_router:, config:)
         @schema = schema
         @monotonic_clock = monotonic_clock
         @logger = logger
         @slow_query_threshold_ms = slow_query_threshold_ms
         @datastore_search_router = datastore_search_router
+        @config = config
       end
 
       # Executes the given `query_string` using the provided `variables`.
@@ -60,11 +61,13 @@ module ElasticGraph
           operation_name: operation_name,
           client: client,
           context: context.merge({
+            logger: @logger,
             monotonic_clock_deadline: timeout_in_ms&.+(start_time_in_ms),
             elastic_graph_schema: @schema,
             schema_element_names: @schema.element_names,
             elastic_graph_query_tracker: query_tracker,
-            datastore_search_router: @datastore_search_router
+            datastore_search_router: @datastore_search_router,
+            nested_relationship_resolver_mode: @config.nested_relationship_resolver_mode
           }.compact)
         )
 
@@ -101,12 +104,16 @@ module ElasticGraph
             "query_fingerprint" => fingerprint_for(query),
             "query_name" => query.operation_name,
             "duration_ms" => duration,
-            # Here we log how long the datastore queries took according to what the datastore itself reported.
+            # How long the datastore queries took according to what the datastore itself reported.
             "datastore_server_duration_ms" => query_tracker.datastore_query_server_duration_ms,
-            # Here we log an estimate for how much overhead ElasticGraph added on top of how long the datastore took.
+            # An estimate for how much overhead ElasticGraph added on top of how long the datastore took.
             # This is based on the duration, excluding how long the datastore calls took from the client side
             # (e.g. accounting for network latency, serialization time, etc)
             "elasticgraph_overhead_ms" => duration - query_tracker.datastore_query_client_duration_ms,
+            # An estimate for the time spent on transport (network latency, JSON serialization, etc).
+            "datastore_request_transport_duration_ms" => query_tracker.datastore_request_transport_duration_ms,
+            # How many datastore shards were queried, in total. This is a measure of how much load the query caused on the datastore.
+            "queried_shard_count" => query_tracker.queried_shard_count,
             # According to https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html#metric-filters-extract-json,
             # > Value nodes can be strings or numbers...If a property selector points to an array or object, the metric filter won't match the log format.
             # So, to allow flexibility to deal with cloud watch metric filters, we coerce these values to a string here.

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

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at
@@ -15,16 +15,11 @@ module ElasticGraph
     module Resolvers
       # Responsible for fetching a single field value from a document.
       class GetRecordFieldValue
-        def initialize(schema_element_names:)
-          @schema_element_names = schema_element_names
+        def initialize(elasticgraph_graphql:, config:)
+          @schema_element_names = elasticgraph_graphql.runtime_metadata.schema_element_names
         end
 
-        def can_resolve?(field:, object:)
-          object.is_a?(DatastoreResponse::Document) || object.is_a?(::Hash)
-        end
-
-        def resolve(field:, object:, args:, context:, lookahead:)
-          field_name = field.name_in_index.to_s
+        def resolve(field:, object:, args:, context:)
           data =
             case object
             when DatastoreResponse::Document
@@ -33,9 +28,8 @@ module ElasticGraph
               object
             end
 
-          value = Support::HashUtil.fetch_value_at_path(data, field_name) do
-            field.type.list? ? [] : nil
-          end
+          value = Support::HashUtil.fetch_value_at_path(data, field.path_in_index) { nil }
+          value = [] if value.nil? && field.type.list?
 
           if field.type.relay_connection?
             RelayConnection::ArrayAdapter.build(value, args, @schema_element_names, context)

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

@@ -0,0 +1,123 @@
+# Copyright 2024 - 2025 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/errors"
+
+module ElasticGraph
+  class GraphQL
+    module Resolvers
+      # Provides an adapter to the GraphQL gem by building a resolver implementation hash as documented here:
+      #
+      # https://graphql-ruby.org/schema/sdl.html
+      class GraphQLAdapterBuilder
+        def initialize(runtime_metadata:, named_resolvers:, query_adapter:)
+          @runtime_metadata = runtime_metadata
+          @named_resolvers = named_resolvers
+          @query_adapter = query_adapter
+        end
+
+        def build
+          scalar_type_hash
+            .merge(object_type_hash)
+            .merge({"resolve_type" => _ = ->(supertype, obj, ctx) { resolve_type(supertype, obj, ctx) }})
+        end
+
+        private
+
+        def scalar_type_hash
+          @runtime_metadata.scalar_types_by_name.transform_values do |scalar_type|
+            adapter = (_ = scalar_type.load_coercion_adapter.extension_class) # : SchemaArtifacts::_ScalarCoercionAdapter[untyped, untyped]
+            {
+              "coerce_input" => ->(value, ctx) { adapter.coerce_input(value, ctx) },
+              "coerce_result" => ->(value, ctx) { adapter.coerce_result(value, ctx) }
+            }
+          end
+        end
+
+        def object_type_hash
+          @runtime_metadata.object_types_by_name.filter_map do |type_name, type|
+            fields_hash = type.graphql_fields_by_name.filter_map do |field_name, field|
+              if (resolver_name = field.resolver)
+                resolver = @named_resolvers.fetch(resolver_name) do
+                  raise Errors::SchemaError, "Resolver `#{resolver_name}` (for `#{type_name}.#{field_name}`) cannot be found."
+                end
+
+                resolver_lambda =
+                  if resolver.method(:resolve).parameters.include?([:keyreq, :lookahead])
+                    lambda do |object, args, context|
+                      schema_field = context.fetch(:elastic_graph_schema).field_named(type_name, field_name)
+
+                      # Extract the `:lookahead` extra that we have configured all fields to provide.
+                      # See https://graphql-ruby.org/api-doc/1.10.8/GraphQL/Execution/Lookahead.html for more info.
+                      # It is not a "real" arg in the schema and breaks `args_to_schema_form` when we call that
+                      # so we need to peel it off here.
+                      lookahead = args[:lookahead]
+
+                      # Convert args to the form they were defined in the schema, undoing the normalization
+                      # the GraphQL gem does to convert them to Ruby keyword args form.
+                      args = schema_field.args_to_schema_form(args.except(:lookahead))
+
+                      result = resolver.resolve(field: schema_field, object: object, args: args, context: context, lookahead: lookahead) do
+                        @query_adapter.build_query_from(field: schema_field, args: args, lookahead: lookahead, context: context)
+                      end
+
+                      # Give the field a chance to coerce the result before returning it. Initially, this is only used to deal with
+                      # enum value overrides (e.g. so that if `DayOfWeek.MONDAY` has been overridden to `DayOfWeek.MON`, we can coerce
+                      # a `MONDAY` value being returned by a painless script to `MON`), but this is designed to be general purpose
+                      # and we may use it for other coercions in the future.
+                      #
+                      # Note that coercion of scalar values is handled by the `coerce_result` callback below.
+                      schema_field.coerce_result(result)
+                    end
+                  else
+                    lambda do |object, args, context|
+                      schema_field = context.fetch(:elastic_graph_schema).field_named(type_name, field_name)
+                      # Convert args to the form they were defined in the schema, undoing the normalization
+                      # the GraphQL gem does to convert them to Ruby keyword args form.
+                      args = schema_field.args_to_schema_form(args)
+
+                      result = resolver.resolve(field: schema_field, object: object, args: args, context: context)
+
+                      # Give the field a chance to coerce the result before returning it. Initially, this is only used to deal with
+                      # enum value overrides (e.g. so that if `DayOfWeek.MONDAY` has been overridden to `DayOfWeek.MON`, we can coerce
+                      # a `MONDAY` value being returned by a painless script to `MON`), but this is designed to be general purpose
+                      # and we may use it for other coercions in the future.
+                      #
+                      # Note that coercion of scalar values is handled by the `coerce_result` callback below.
+                      schema_field.coerce_result(result)
+                    end
+                  end
+
+                [field_name, resolver_lambda]
+              end
+            end.to_h
+
+            unless fields_hash.empty?
+              [type_name, fields_hash]
+            end
+          end.to_h
+        end
+
+        # In order to support unions and interfaces, we must implement `resolve_type`.
+        def resolve_type(supertype, object, context)
+          schema = context.fetch(:elastic_graph_schema)
+          # If `__typename` is available, use that to resolve. It should be available on any embedded abstract types...
+          # (See `Inventor` in `config/schema.graphql` for an example of this kind of type union.)
+          if (typename = object["__typename"])
+            schema.graphql_schema.possible_types(supertype).find { |t| t.graphql_name == typename }
+          else
+            # ...otherwise infer the type based on what index the object came from. This is the case
+            # with unions/interfaces of individually indexed types.
+            # (See `Part` in `config/schema/widgets.rb` for an example of this kind of type union.)
+            schema.document_type_stored_in(object.index_definition_name).graphql_type
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at
@@ -14,11 +14,11 @@ module ElasticGraph
     module Resolvers
       # Responsible for fetching a a list of records of a particular type
       class ListRecords
-        def can_resolve?(field:, object:)
-          field.parent_type.name == :Query && field.type.collection?
+        def initialize(elasticgraph_graphql:, config:)
+          # Nothing to initialize, but needs to be defined to satisfy the resolver interface.
         end
 
-        def resolve(field:, context:, lookahead:, **)
+        def resolve(field:, object:, args:, context:, lookahead:)
           query = yield
           response = QuerySource.execute_one(query, for_context: context)
           RelayConnection.maybe_wrap(response, field: field, context: context, lookahead: lookahead, query: query)

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

@@ -1,4 +1,4 @@
-# Copyright 2024 Block, Inc.
+# Copyright 2024 - 2025 Block, Inc.
 #
 # Use of this source code is governed by an MIT-style
 # license that can be found in the LICENSE file or at
@@ -6,7 +6,9 @@
 #
 # frozen_string_literal: true
 
+require "elastic_graph/graphql/resolvers/nested_relationships_source"
 require "elastic_graph/graphql/resolvers/relay_connection"
+require "elastic_graph/graphql/datastore_response/search_response"
 
 module ElasticGraph
   class GraphQL
@@ -17,31 +19,32 @@ module ElasticGraph
       #
       # Most of the logic for this lives in ElasticGraph::Schema::RelationJoin.
       class NestedRelationships
-        def initialize(schema_element_names:, logger:)
-          @schema_element_names = schema_element_names
-          @logger = logger
+        def initialize(elasticgraph_graphql:, config:)
+          @schema_element_names = elasticgraph_graphql.runtime_metadata.schema_element_names
+          @logger = elasticgraph_graphql.logger
+          @monotonic_clock = elasticgraph_graphql.monotonic_clock
+          @resolver_mode = elasticgraph_graphql.config.nested_relationship_resolver_mode
         end
 
-        def can_resolve?(field:, object:)
-          !!field.relation_join
-        end
-
-        def resolve(object:, field:, context:, lookahead:, **)
+        def resolve(field:, object:, args:, context:, lookahead:)
           log_warning = ->(**options) { log_field_problem_warning(field: field, **options) }
           join = field.relation_join
           id_or_ids = join.extract_id_or_ids_from(object, log_warning)
-          filters = [
-            build_filter(join.filter_id_field_name, nil, join.foreign_key_nested_paths, Array(id_or_ids)),
-            join.additional_filter
-          ].reject(&:empty?)
-          query = yield.merge_with(filters: filters)
+          query = yield
 
           response =
             case id_or_ids
             when nil, []
               join.blank_value
             else
-              initial_response = QuerySource.execute_one(query, for_context: context)
+              initial_response = try_synthesize_response_from_ids(field, id_or_ids, query) ||
+                NestedRelationshipsSource.execute_one(
+                  Array(id_or_ids).to_set,
+                  query:, join:, context:,
+                  monotonic_clock: @monotonic_clock,
+                  mode: @resolver_mode
+                )
+
               join.normalize_documents(initial_response) do |problem|
                 log_warning.call(document: {"id" => id_or_ids}, problem: "got #{problem} from the datastore search query")
               end
@@ -52,22 +55,49 @@ module ElasticGraph
 
         private
 
+        ONLY_ID = ["id"]
+
+        # When a client requests only the `id` from a nested relationship, and we already have those ids,
+        # we want to avoid querying the datastore, and synthesize a response instead.
+        def try_synthesize_response_from_ids(field, id_or_ids, query)
+          # This optimization can only be used on a relationship with an outbound foreign key.
+          return nil if field.relation.direction == :in
+
+          # If the client is requesting any fields besides `id`, we can't do this.
+          return nil unless (query.requested_fields - ONLY_ID).empty?
+
+          pagination = query.document_paginator.to_datastore_body
+          search_after = pagination.dig(:search_after, 0)
+          ids = Array(id_or_ids)
+
+          sorted_ids =
+            case pagination.dig(:sort, 0, "id", "order")
+            when "asc"
+              ids.sort.select { |id| search_after.nil? || id > search_after }
+            when "desc"
+              ids.sort.reverse.select { |id| search_after.nil? || id < search_after }
+            else
+              if ids.size < 2
+                ids
+              else
+                # The client is sorting by something other than `id` and we have multiple ids.
+                # We aren't able to determine the correct order for the ids, so we can't synthesize
+                # a response.
+                return nil
+              end
+            end
+
+          DatastoreResponse::SearchResponse.synthesize_from_ids(
+            query.search_index_expression,
+            sorted_ids.first(pagination.fetch(:size)),
+            decoded_cursor_factory: query.send(:decoded_cursor_factory)
+          )
+        end
+
         def log_field_problem_warning(field:, document:, problem:)
           id = document.fetch("id", "<no id>")
           @logger.warn "#{field.parent_type.name}(id: #{id}).#{field.name} had a problem: #{problem}"
         end
-
-        def build_filter(path, previous_nested_path, nested_paths, ids)
-          if nested_paths.empty?
-            path = path.delete_prefix("#{previous_nested_path}.") if previous_nested_path
-            {path => {@schema_element_names.equal_to_any_of => ids}}
-          else
-            next_nested_path, *rest_nested_paths = nested_paths
-            sub_filter = build_filter(path, next_nested_path, rest_nested_paths, ids)
-            next_nested_path = next_nested_path.delete_prefix("#{previous_nested_path}.") if previous_nested_path
-            {next_nested_path => {@schema_element_names.any_satisfy => sub_filter}}
-          end
-        end
       end
     end
   end