graphql 2.5.12 → 2.5.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e59a0d63055f40c6802e504d0a0b12fa4a0b36d73caba86f2879966d13fc31e
-  data.tar.gz: 38416d067f73335742755e9fe11825e591d6ecd999360074e469f8b6ceea0908
+  metadata.gz: deb0ac3bea401c53909c6880f133ee810f3e0882c7a023ed33b27f7b12a4c82b
+  data.tar.gz: be2d8e55d131a62863d4ecf6665c22c9ba6c9ba467bdd205ec83d96f9b952098
 SHA512:
-  metadata.gz: af2f66ced060a82f5869586c41917a7dfd12d44478f63f48b80b96fef563b0f3c0294e1aa5d16256740362474f70523f983a6bec47d400408392dce46ab62445
-  data.tar.gz: cf1361a8d27f9ec47de57aa76f58f33757652a4765d8e887cf13079b8e0873a7d983dc94d1022cda045d56e6c3e6f39e2ce966685681da98084179e604883bb1
+  metadata.gz: 494296336070a677965ceaaad1e14412f1b8a6589ab3ae3466c5c00071a59f763f2af2df8aacd394c9fd912afd0a5f9df988991411213dbfab285d762d1a6e75
+  data.tar.gz: 8d65056236ddb32eabe498d93bb026f8d7ea145b627d6a4554b2add2d8c00db202f9bbe16cae816e58aeb6dd77f3e8aed99dcaa802af2643f73b03a5d10b0b63

data/lib/graphql/execution/interpreter/runtime/graphql_result.rb

@@ -42,6 +42,14 @@ module GraphQL
             end
           end
 
+          def depth
+            @depth ||= if @graphql_parent
+              @graphql_parent.depth + 1
+            else
+              1
+            end
+          end
+
           attr_accessor :graphql_dead
           attr_reader :graphql_parent, :graphql_result_name, :graphql_is_non_null_in_parent,
             :graphql_application_value, :graphql_result_type, :graphql_selections, :graphql_is_eager, :ast_node, :graphql_arguments, :graphql_field

data/lib/graphql/execution/interpreter/runtime.rb

@@ -890,7 +890,6 @@ module GraphQL
         # @return [GraphQL::Execution::Lazy, Object] If loading `object` will be deferred, it's a wrapper over it.
         def after_lazy(lazy_obj, field:, owner_object:, arguments:, ast_node:, result:, result_name:, eager: false, runtime_state:, trace: true, &block)
           if lazy?(lazy_obj)
-            orig_result = result
             was_authorized_by_scope_items = runtime_state.was_authorized_by_scope_items
             lazy = GraphQL::Execution::Lazy.new(field: field) do
               # This block might be called in a new fiber;
@@ -900,13 +899,13 @@ module GraphQL
               runtime_state.current_field = field
               runtime_state.current_arguments = arguments
               runtime_state.current_result_name = result_name
-              runtime_state.current_result = orig_result
+              runtime_state.current_result = result
               runtime_state.was_authorized_by_scope_items = was_authorized_by_scope_items
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
-              result = nil
+              sync_result = nil
               inner_obj = begin
-                result = if trace
+                sync_result = if trace
                   @current_trace.begin_execute_field(field, owner_object, arguments, query)
                   @current_trace.execute_field_lazy(field: field, query: query, object: owner_object, arguments: arguments, ast_node: ast_node) do
                     schema.sync_lazy(lazy_obj)
@@ -924,7 +923,7 @@ module GraphQL
                 end
               ensure
                 if trace
-                  @current_trace.end_execute_field(field, owner_object, arguments, query, result)
+                  @current_trace.end_execute_field(field, owner_object, arguments, query, sync_result)
                 end
               end
               yield(inner_obj, runtime_state)
@@ -934,12 +933,7 @@ module GraphQL
               lazy.value
             else
               set_result(result, result_name, lazy, false, false) # is_non_null is irrelevant here
-              current_depth = 0
-              while result
-                current_depth += 1
-                result = result.graphql_parent
-              end
-              @dataloader.lazy_at_depth(current_depth, lazy)
+              @dataloader.lazy_at_depth(result.depth, lazy)
               lazy
             end
           else

data/lib/graphql/schema/directive.rb

@@ -129,11 +129,22 @@ module GraphQL
         # not runtime arguments.
         context = Query::NullContext.instance
         self.class.all_argument_definitions.each do |arg_defn|
-          if arguments.key?(arg_defn.keyword)
-            value = arguments[arg_defn.keyword]
+          keyword = arg_defn.keyword
+          arg_type = arg_defn.type
+          if arguments.key?(keyword)
+            value = arguments[keyword]
             # This is a Ruby-land value; convert it to graphql for validation
             graphql_value = begin
-              arg_defn.type.unwrap.coerce_isolated_result(value)
+              coerce_value = value
+              if arg_type.list? && (!coerce_value.nil?) && (!coerce_value.is_a?(Array))
+                # When validating inputs, GraphQL accepts a single item
+                # and implicitly converts it to a one-item list.
+                # However, we're using result coercion here to go from Ruby value
+                # to GraphQL value, so it doesn't have that feature.
+                # Keep the GraphQL-type behavior but implement it manually:
+                coerce_value = [coerce_value]
+              end
+              arg_type.coerce_isolated_result(coerce_value)
             rescue GraphQL::Schema::Enum::UnresolvedValueError
               # Let validation handle this
               value
@@ -142,7 +153,7 @@ module GraphQL
             value = graphql_value = nil
           end
 
-          result = arg_defn.type.validate_input(graphql_value, context)
+          result = arg_type.validate_input(graphql_value, context)
           if !result.valid?
             raise InvalidArgumentError, "@#{graphql_name}.#{arg_defn.graphql_name} on #{owner.path} is invalid (#{value.inspect}): #{result.problems.first["explanation"]}"
           end

data/lib/graphql/testing/helpers.rb

@@ -39,9 +39,9 @@ module GraphQL
         end
       end
 
-      def run_graphql_field(schema, field_path, object, arguments: {}, context: {}, ast_node: nil, lookahead: nil)
+      def run_graphql_field(schema, field_path, object, arguments: {}, context: {}, ast_node: nil, lookahead: nil, visibility_profile: nil)
         type_name, *field_names = field_path.split(".")
-        dummy_query = GraphQL::Query.new(schema, "{ __typename }", context: context)
+        dummy_query = GraphQL::Query.new(schema, "{ __typename }", context: context, visibility_profile: visibility_profile)
         query_context = dummy_query.context
         dataloader = query_context.dataloader
         object_type = dummy_query.types.type(type_name) # rubocop:disable Development/ContextIsPassedCop
@@ -104,32 +104,35 @@ module GraphQL
         end
       end
 
-      def with_resolution_context(schema, type:, object:, context:{})
+      def with_resolution_context(schema, type:, object:, context:{}, visibility_profile: nil)
         resolution_context = ResolutionAssertionContext.new(
           self,
           schema: schema,
           type_name: type,
           object: object,
-          context: context
+          context: context,
+          visibility_profile: visibility_profile,
         )
         yield(resolution_context)
       end
 
       class ResolutionAssertionContext
-        def initialize(test, type_name:, object:, schema:, context:)
+        def initialize(test, type_name:, object:, schema:, context:, visibility_profile:)
           @test = test
           @type_name = type_name
           @object = object
           @schema = schema
           @context = context
+          @visibility_profile = visibility_profile
         end
 
+        attr_reader :visibility_profile
 
         def run_graphql_field(field_name, arguments: {})
           if @schema
-            @test.run_graphql_field(@schema, "#{@type_name}.#{field_name}", @object, arguments: arguments, context: @context)
+            @test.run_graphql_field(@schema, "#{@type_name}.#{field_name}", @object, arguments: arguments, context: @context, visibility_profile: @visibility_profile)
           else
-            @test.run_graphql_field("#{@type_name}.#{field_name}", @object, arguments: arguments, context: @context)
+            @test.run_graphql_field("#{@type_name}.#{field_name}", @object, arguments: arguments, context: @context, visibility_profile: @visibility_profile)
           end
         end
       end
@@ -137,8 +140,8 @@ module GraphQL
       module SchemaHelpers
         include Helpers
 
-        def run_graphql_field(field_path, object, arguments: {}, context: {})
-          super(@@schema_class_for_helpers, field_path, object, arguments: arguments, context: context)
+        def run_graphql_field(field_path, object, arguments: {}, context: {}, visibility_profile: nil)
+          super(@@schema_class_for_helpers, field_path, object, arguments: arguments, context: context, visibility_profile: visibility_profile)
         end
 
         def with_resolution_context(*args, **kwargs, &block)

data/lib/graphql/tracing/sentry_trace.rb

@@ -41,7 +41,9 @@ module GraphQL
                 if query.selected_operation_name
                   span.set_data('graphql.operation.name', query.selected_operation_name)
                 end
-                span.set_data('graphql.operation.type', query.selected_operation.operation_type)
+                if query.selected_operation
+                  span.set_data('graphql.operation.type', query.selected_operation.operation_type)
+                end
               end
             end
 

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "2.5.12"
+  VERSION = "2.5.14"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.5.12
+  version: 2.5.14
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2025-09-15 00:00:00.000000000 Z
+date: 2025-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64