elasticgraph-graphql 0.19.1.1 → 0.19.2.1

data/lib/elastic_graph/graphql/schema/relation_join.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
@@ -63,21 +63,25 @@ module ElasticGraph
 
         # Normalizes the given documents, ensuring it has the expected cardinality.
         def normalize_documents(response, &handle_warning)
-          doc_cardinality.normalize(response, handle_warning: handle_warning, &:id)
+          doc_cardinality.normalize(response, handle_warning: handle_warning) { |doc| (_ = doc).id }
         end
 
         private
 
         def normalize_ids(id_or_ids, &handle_warning)
-          id_cardinality.normalize(id_or_ids, handle_warning: handle_warning, &:itself)
+          id_cardinality.normalize(id_or_ids, handle_warning: handle_warning) { |id| id }
         end
 
         module Cardinality
           module Many
             def self.normalize(list_or_scalar, handle_warning:)
-              return list_or_scalar if list_or_scalar.is_a?(Enumerable)
-              handle_warning.call("scalar instead of a list")
-              Array(list_or_scalar)
+              case list_or_scalar
+              when ::Enumerable
+                list_or_scalar
+              else
+                handle_warning.call("scalar instead of a list")
+                Array(list_or_scalar)
+              end
             end
 
             def self.blank_value
@@ -87,9 +91,13 @@ module ElasticGraph
 
           module One
             def self.normalize(list_or_scalar, handle_warning:, &deterministic_comparator)
-              return list_or_scalar unless list_or_scalar.is_a?(Enumerable)
-              handle_warning.call("list of more than one item instead of a scalar") if list_or_scalar.size > 1
-              list_or_scalar.min_by(&deterministic_comparator)
+              case list_or_scalar
+              when ::Enumerable
+                handle_warning.call("list of more than one item instead of a scalar") if (_ = list_or_scalar).size > 1
+                list_or_scalar.min_by(&deterministic_comparator)
+              else
+                list_or_scalar
+              end
             end
 
             def self.blank_value

data/lib/elastic_graph/graphql/schema/type.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
@@ -24,7 +24,8 @@ module ElasticGraph
           graphql_type,
           index_definitions,
           object_runtime_metadata,
-          enum_runtime_metadata
+          enum_runtime_metadata,
+          resolvers_needing_lookahead
         )
           @schema = schema
           @graphql_type = graphql_type
@@ -37,6 +38,7 @@ module ElasticGraph
           @elasticgraph_category = object_runtime_metadata&.elasticgraph_category
           @graphql_only_return_type = object_runtime_metadata&.graphql_only_return_type
           @enum_runtime_metadata = enum_runtime_metadata
+          @resolvers_needing_lookahead = resolvers_needing_lookahead
           @enum_value_names_by_original_name = (enum_runtime_metadata&.values_by_name || {}).to_h do |name, value|
             [value.alternate_original_name || name, name]
           end
@@ -45,7 +47,7 @@ module ElasticGraph
         end
 
         def name
-          @name ||= @graphql_type.to_type_signature.to_sym
+          @name ||= @graphql_type.to_type_signature
         end
 
         # List of index definitions that should be searched for this type.
@@ -110,11 +112,14 @@ module ElasticGraph
         # Returns the subtypes of this type, if it has any. This is like `#possible_types` provided by the
         # GraphQL gem, but that includes a type itself when you ask for the possible types of a non-abstract type.
         def subtypes
-          @subtypes ||= @schema.graphql_schema.possible_types(graphql_type).map { |t| @schema.type_from(t) } - [self]
+          @subtypes ||= @schema
+            .graphql_schema
+            .possible_types(graphql_type, visibility_profile: :boot)
+            .map { |t| @schema.type_from(t) } - [self]
         end
 
         def field_named(field_name)
-          @fields_by_name.fetch(field_name.to_s)
+          @fields_by_name.fetch(field_name)
         rescue KeyError => e
           msg = "No field named #{field_name} (on type #{name}) could be found"
           msg += "; Possible alternatives: [#{e.corrections.join(", ").delete('"')}]." if e.corrections.any?
@@ -122,7 +127,7 @@ module ElasticGraph
         end
 
         def enum_value_named(enum_value_name)
-          @enum_values_by_name[enum_value_name.to_s]
+          @enum_values_by_name[enum_value_name]
         end
 
         def coerce_result(result)
@@ -226,7 +231,7 @@ module ElasticGraph
           graphql_enum_value = @graphql_type.values.fetch(enum_value_name)
 
           EnumValue.new(
-            name: graphql_enum_value.graphql_name.to_sym,
+            name: graphql_enum_value.graphql_name,
             type: self,
             runtime_metadata: @enum_runtime_metadata&.values_by_name&.dig(enum_value_name)
           )
@@ -250,7 +255,13 @@ module ElasticGraph
           # Eagerly fan out and instantiate all `Field` objects so that the :extras
           # get added to each field as require before we execute the first query
           fields_hash.each_with_object({}) do |(name, field), hash|
-            hash[name] = Field.new(schema, self, field, @object_runtime_metadata&.graphql_fields_by_name&.dig(name))
+            hash[name] = Field.new(
+              schema,
+              self,
+              field,
+              @object_runtime_metadata&.graphql_fields_by_name&.dig(name),
+              @resolvers_needing_lookahead
+            )
           end
         end
 

data/lib/elastic_graph/graphql/schema.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,16 +6,11 @@
 #
 # frozen_string_literal: true
 
-require "digest/md5"
-require "forwardable"
 require "graphql"
 require "elastic_graph/constants"
 require "elastic_graph/errors"
-require "elastic_graph/graphql/monkey_patches/schema_field"
-require "elastic_graph/graphql/monkey_patches/schema_object"
 require "elastic_graph/graphql/schema/field"
 require "elastic_graph/graphql/schema/type"
-require "elastic_graph/support/hash_util"
 
 module ElasticGraph
   # Wraps a GraphQL::Schema object in order to provide higher-level, more convenient APIs
@@ -29,19 +24,27 @@ module ElasticGraph
         scalar_types.to_set.union(introspection_types)
       )
 
-      attr_reader :element_names, :config, :graphql_schema, :runtime_metadata
+      attr_reader :element_names, :config, :logger, :graphql_schema, :runtime_metadata
 
       def initialize(
         graphql_schema_string:,
         config:,
+        logger:,
         runtime_metadata:,
+        datastore_search_router:,
         index_definitions_by_graphql_type:,
         graphql_gem_plugins:,
-        &build_resolver
+        graphql_adapter:
       )
         @element_names = runtime_metadata.schema_element_names
         @config = config
+        @logger = logger
         @runtime_metadata = runtime_metadata
+        @datastore_search_router = datastore_search_router
+
+        resolvers_needing_lookahead = runtime_metadata.graphql_resolvers_by_name.filter_map do |name, resolver|
+          name if resolver.needs_lookahead
+        end.to_set
 
         @types_by_graphql_type = Hash.new do |hash, key|
           hash[key] = Type.new(
@@ -49,25 +52,55 @@ module ElasticGraph
             key,
             index_definitions_by_graphql_type[key.graphql_name] || [],
             runtime_metadata.object_types_by_name[key.graphql_name],
-            runtime_metadata.enum_types_by_name[key.graphql_name]
+            runtime_metadata.enum_types_by_name[key.graphql_name],
+            resolvers_needing_lookahead
           )
         end
 
-        @build_resolver = build_resolver
-
         # Note: as part of loading the schema, the GraphQL gem may use the resolver (such
         # when a directive has a custom scalar) so we must wait to instantiate the schema
         # as late as possible here. If we do this before initializing some of the instance
         # variables above we'll get `NoMethodError` on `nil`.
         @graphql_schema = ::GraphQL::Schema.from_definition(
           graphql_schema_string,
-          default_resolve: LazyResolverAdapter.new(method(:resolver)),
+          base_types: {object: build_base_object_class},
+          default_resolve: graphql_adapter,
           using: graphql_gem_plugins
         )
 
         # 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.
         @types_by_name = build_types_by_name
+        @graphql_schema.visibility.preload
+
+        log_hidden_types
+      end
+
+      def new_graphql_query(
+        query_string,
+        operation_name: nil,
+        variables: {},
+        context: {},
+        document: nil,
+        validate: true
+      )
+        ::GraphQL::Query.new(
+          graphql_schema,
+          query_string,
+          variables: variables,
+          operation_name: operation_name,
+          document: document,
+          validate: validate,
+          context: context.merge({
+            datastore_search_router: @datastore_search_router,
+            elastic_graph_schema: self,
+            visibility_profile: VISIBILITY_PROFILE
+          })
+        )
+      end
+
+      def graphql_query_context
+        @graphql_query_context ||= new_graphql_query(nil).context
       end
 
       def type_from(graphql_type)
@@ -79,7 +112,7 @@ 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.fetch(type_name.to_s)
+        @types_by_name.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?
@@ -114,33 +147,44 @@ module ElasticGraph
       end
 
       def to_s
-        "#<#{self.class.name} 0x#{__id__.to_s(16)} indexed_document_types=#{indexed_document_types.map(&:name).sort.to_s.delete(":")}>"
+        "#<#{self.class.name} 0x#{__id__.to_s(16)} indexed_document_types=[#{indexed_document_types.map(&:name).sort.join(", ")}]>"
       end
       alias_method :inspect, :to_s
 
       private
 
-      # Adapter class to allow us to lazily load the resolver instance.
-      #
-      # Necessary because the resolver must be provided to `GraphQL::Schema.from_definition`,
-      # but the resolver logic itself depends upon the loaded schema to know how to resolve.
-      # To work around the circular dependency, we build the schema with this lazy adapter,
-      # then build the resolver with the schema, and then the lazy resolver lazily loads the resolver.
-      LazyResolverAdapter = Struct.new(:builder) do
-        def resolver
-          @resolver ||= builder.call
+      def build_base_object_class
+        schema = self
+
+        base_field_class = ::Class.new(::GraphQL::Schema::Field) do
+          define_method :visible? do |context|
+            return super(context) if context[:visibility_profile] == :boot
+
+            if schema.field_named(owner.graphql_name, graphql_name).hidden_from_queries?
+              return false
+            end
+
+            super(context)
+          end
         end
 
-        extend Forwardable
-        def_delegators :resolver, :call, :resolve_type, :coerce_input, :coerce_result
-      end
+        ::Class.new(::GraphQL::Schema::Object) do
+          field_class base_field_class
+
+          define_singleton_method :visible? do |context|
+            return super(context) if context[:visibility_profile] == :boot
+
+            if schema.type_named(graphql_name).hidden_from_queries?
+              return false
+            end
 
-      def resolver
-        @resolver ||= @build_resolver.call(self)
+            super(context)
+          end
+        end
       end
 
       def build_types_by_name
-        graphql_schema.types.transform_values do |graphql_type|
+        graphql_schema.types(visibility_profile: :boot).transform_values do |graphql_type|
           @types_by_graphql_type[graphql_type]
         end
       end
@@ -156,6 +200,16 @@ module ElasticGraph
           end
         end.freeze
       end
+
+      def log_hidden_types
+        hidden_types = @types_by_name.values.select(&:hidden_from_queries?)
+        return if hidden_types.empty?
+
+        logger.warn(
+          "#{hidden_types.size} GraphQL types were hidden from the schema due to their backing indices being " \
+          "inaccessible: #{hidden_types.map(&:name).sort.join(", ")}"
+        )
+      end
     end
   end
 end

data/lib/elastic_graph/graphql.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
@@ -8,6 +8,7 @@
 
 require "elastic_graph/datastore_core"
 require "elastic_graph/graphql/config"
+require "elastic_graph/constants"
 require "elastic_graph/support/from_yaml_file"
 
 module ElasticGraph
@@ -26,7 +27,7 @@ module ElasticGraph
     def self.from_parsed_yaml(parsed_yaml, &datastore_client_customization_block)
       new(
         config: GraphQL::Config.from_parsed_yaml(parsed_yaml),
-        datastore_core: DatastoreCore.from_parsed_yaml(parsed_yaml, for_context: :graphql, &datastore_client_customization_block)
+        datastore_core: DatastoreCore.from_parsed_yaml(parsed_yaml, &datastore_client_customization_block)
       )
     end
 
@@ -55,7 +56,7 @@ module ElasticGraph
 
       # Apply any extension modules that have been configured.
       @config.extension_modules.each { |mod| extend mod }
-      @runtime_metadata.graphql_extension_modules.each { |ext_mod| extend ext_mod.extension_class }
+      @runtime_metadata.graphql_extension_modules.each { |ext_mod| extend ext_mod.load_extension.extension_class }
     end
 
     # @private
@@ -78,8 +79,7 @@ module ElasticGraph
           schema: schema,
           monotonic_clock: monotonic_clock,
           logger: logger,
-          slow_query_threshold_ms: @config.slow_query_latency_warning_threshold_in_ms,
-          datastore_search_router: datastore_search_router
+          slow_query_threshold_ms: @config.slow_query_latency_warning_threshold_in_ms
         )
       end
     end
@@ -88,26 +88,16 @@ module ElasticGraph
     def schema
       @schema ||= begin
         require "elastic_graph/graphql/schema"
-
         Schema.new(
           graphql_schema_string: graphql_schema_string,
           config: config,
+          logger: logger,
           runtime_metadata: runtime_metadata,
+          datastore_search_router: datastore_search_router,
           index_definitions_by_graphql_type: @datastore_core.index_definitions_by_graphql_type,
-          graphql_gem_plugins: graphql_gem_plugins
-        ) do |schema|
-          @graphql_adapter || begin
-            @schema = schema # assign this so that `#schema` returns the schema when `datastore_query_adapters` is called below
-            require "elastic_graph/graphql/resolvers/graphql_adapter"
-            Resolvers::GraphQLAdapter.new(
-              schema: schema,
-              datastore_query_builder: datastore_query_builder,
-              datastore_query_adapters: datastore_query_adapters,
-              runtime_metadata: runtime_metadata,
-              resolvers: graphql_resolvers
-            )
-          end
-        end
+          graphql_gem_plugins: graphql_gem_plugins,
+          graphql_adapter: graphql_adapter
+        )
       end
     end
 
@@ -128,7 +118,7 @@ module ElasticGraph
     def datastore_query_builder
       @datastore_query_builder ||= begin
         require "elastic_graph/graphql/datastore_query"
-        DatastoreQuery::Builder.with(
+        DatastoreQuery::Builder.new(
           filter_interpreter:,
           filter_node_interpreter:,
           runtime_metadata:,
@@ -143,35 +133,57 @@ module ElasticGraph
     def graphql_gem_plugins
       @graphql_gem_plugins ||= begin
         require "graphql"
+        # As per https://graphql-ruby.org/language_tools/c_parser.html, loading the
+        # C parser causes the faster parser to be assigned as the `::GraphQL.default_parser`,
+        # providing greater efficiency.
+        #
+        # We load it here since this is where we load the GraphQL gem.
+        require "graphql/c_parser"
+
         {
           # 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}
+          # https://graphql-ruby.org/authorization/visibility.html
+          ::GraphQL::Schema::Visibility => {
+            # The GraphQL gem internally cache the visibility per profile. Ideally, we'd have only a single profile,
+            # but that makes for a chicken-and-egg problem: our visibility logic depends on the schema being fully
+            # loaded, but the `visibility?` methods are called while loading the schema. To deal with that, we're
+            # using tw profiles:
+            #
+            # - `boot` is used while loading, and skips our normal visibility logic.
+            # - `main` is used after that and uses our normal visibility logic.
+            profiles: {:boot => {}, VISIBILITY_PROFILE => {}} # : ::Hash[::Symbol, ::Hash[::Symbol, untyped]]
+          }
         }
       end
     end
 
-    # @private
-    def graphql_resolvers
-      @graphql_resolvers ||= begin
-        require "elastic_graph/graphql/resolvers/get_record_field_value"
-        require "elastic_graph/graphql/resolvers/list_records"
-        require "elastic_graph/graphql/resolvers/nested_relationships"
-
-        nested_relationships = Resolvers::NestedRelationships.new(
-          schema_element_names: runtime_metadata.schema_element_names,
-          logger: logger
-        )
-
-        list_records = Resolvers::ListRecords.new
+    def graphql_adapter
+      @graphql_adapter ||= begin
+        require "elastic_graph/graphql/resolvers/graphql_adapter_builder"
+        Resolvers::GraphQLAdapterBuilder.new(
+          named_resolvers: named_graphql_resolvers,
+          query_adapter: resolver_query_adapter,
+          runtime_metadata: runtime_metadata
+        ).build
+      end
+    end
 
-        get_record_field_value = Resolvers::GetRecordFieldValue.new(
-          schema_element_names: runtime_metadata.schema_element_names
+    def resolver_query_adapter
+      @resolver_query_adapter ||= begin
+        require "elastic_graph/graphql/resolvers/query_adapter"
+        Resolvers::QueryAdapter.new(
+          datastore_query_builder: datastore_query_builder,
+          datastore_query_adapters: datastore_query_adapters
         )
+      end
+    end
 
-        [nested_relationships, list_records, get_record_field_value]
+    # @private
+    def named_graphql_resolvers
+      @named_graphql_resolvers ||= runtime_metadata.graphql_resolvers_by_name.transform_values do |resolver|
+        ext = resolver.load_resolver
+        (_ = ext.extension_class).new(elasticgraph_graphql: self, config: ext.config)
       end
     end
 
@@ -194,14 +206,13 @@ module ElasticGraph
             filter_node_interpreter: filter_node_interpreter
           ),
           GraphQL::QueryAdapter::Sort.new(order_by_arg_name: schema_element_names.order_by),
-          Aggregation::QueryAdapter.new(
-            schema: schema,
+          Aggregation::QueryAdapter::WithoutSchema.new(
             config: config,
             filter_args_translator: filter_args_translator,
             runtime_metadata: runtime_metadata,
             sub_aggregation_grouping_adapter: sub_aggregation_grouping_adapter
           ),
-          GraphQL::QueryAdapter::RequestedFields.new(schema)
+          GraphQL::QueryAdapter::RequestedFields::WithoutSchema.new
         ]
       end
     end
@@ -252,6 +263,8 @@ module ElasticGraph
     # it's nice to load dependencies when needed.
     def load_dependencies_eagerly
       require "graphql"
+      require "graphql/c_parser"
+
       ::GraphQL.eager_load!
 
       # run a simple GraphQL query to force load any dependencies needed to handle GraphQL queries

data/script/dump_time_zones

@@ -8,7 +8,7 @@ updated_code_filename = "#{__dir__}/../../tmp/updated_valid_time_zones.rb"
 java_time_zones = `java --source 11 #{__dir__}/dump_time_zones.java`.split("\n")
 
 ::File.write(updated_code_filename, <<~EOS)
-  # 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