graphql 2.5.4 → 2.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fcafc24832a376132e4f15c981133f693685ad070918284587f775d05dd44d7
-  data.tar.gz: 41bba1c56371a6d4ad643f75cece09cc13474dcf02b24dce0b31a1c8c89ee480
+  metadata.gz: f669e7593a3d951ee74480991e79d6a10fcd4b069746cd6244897b32fb6373fa
+  data.tar.gz: decb90c238b320f288b9a672b068e543745b9f46f82249fe93771230f8096257
 SHA512:
-  metadata.gz: 308136d27234edd6c84310f1e18d5a5841cdbcbf7ca8fe56eb9dd070fa52c10ad6d4d46022b51d22fe4adbcae9f7428ea6a6d7b756eef5d2be1f1337393a3f3b
-  data.tar.gz: a0a3027d2f155daa8e52156765f6f6dcd53b35057ba010cc9e0ece130c283e2a5292c020eee81882074b6e7524c0085670dba9d47337619279915df18e097655
+  metadata.gz: f1afa8434158b861073704a39b1ce84ee76c2bd636669c734ab43af66cf15c396ddaadc2f7c1dcf1fa61c030a0bddc0fc362f6db1bc6ad144efcaa61142565fd
+  data.tar.gz: ef88e624f49aafc803c6acfef8e44e1336f3494ce83bdf5b074825450cc6bc10eafd5738b012e177ceb5581c0425b9e93466e84d50bcec28b00169dbbc82c9b5

data/lib/graphql/analysis/query_complexity.rb

@@ -28,14 +28,14 @@ module GraphQL
           end
         when nil
           subject.logger.warn <<~GRAPHQL
-            GraphQL-Ruby's complexity cost system is getting some "breaking fixes" in a future version. See the migration notes at https://graphql-ruby.org/api-docs/#{GraphQL::VERSION}/Schema.html#complexity_cost_cacluation_mode-class_method
+            GraphQL-Ruby's complexity cost system is getting some "breaking fixes" in a future version. See the migration notes at https://graphql-ruby.org/api-doc/#{GraphQL::VERSION}/GraphQL/Schema.html#complexity_cost_calculation_mode_for-class_method
 
             To opt into the future behavior, configure your schema (#{subject.schema.name ? subject.schema.name : subject.schema.ancestors}) with:
 
               complexity_cost_calculation_mode(:future) # or `:legacy`, `:compare`
 
           GRAPHQL
-          max_possible_complexity
+          max_possible_complexity(mode: :legacy)
         else
           raise ArgumentError, "Expected `:future`, `:legacy`, `:compare`, or `nil` from `#{query.schema}.complexity_cost_calculation_mode_for` but got: #{query.schema.complexity_cost_calculation_mode.inspect}"
         end

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

@@ -21,15 +21,25 @@ module GraphQL
             @graphql_metadata = nil
             @graphql_selections = selections
             @graphql_is_eager = is_eager
+            @base_path = nil
           end
 
+          # TODO test full path in Partial
+          attr_writer :base_path
+
           def path
             @path ||= build_path([])
           end
 
           def build_path(path_array)
             graphql_result_name && path_array.unshift(graphql_result_name)
-            @graphql_parent ? @graphql_parent.build_path(path_array) : path_array
+            if @graphql_parent
+              @graphql_parent.build_path(path_array)
+            elsif @base_path
+              @base_path + path_array
+            else
+              path_array
+            end
           end
 
           attr_accessor :graphql_dead

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

@@ -57,53 +57,142 @@ module GraphQL
         end
 
         def final_result
-          @response && @response.graphql_result_data
+          @response.respond_to?(:graphql_result_data) ? @response.graphql_result_data : @response
         end
 
         def inspect
           "#<#{self.class.name} response=#{@response.inspect}>"
         end
 
-        # This _begins_ the execution. Some deferred work
-        # might be stored up in lazies.
         # @return [void]
         def run_eager
-          root_operation = query.selected_operation
-          root_op_type = root_operation.operation_type || "query"
-          root_type = schema.root_type_for_operation(root_op_type)
-          runtime_object = root_type.wrap(query.root_value, context)
-          runtime_object = schema.sync_lazy(runtime_object)
-          is_eager = root_op_type == "mutation"
-          @response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false, root_operation.selections, is_eager, root_operation, nil, nil)
-          st = get_current_runtime_state
-          st.current_result = @response
-
-          if runtime_object.nil?
-            # Root .authorized? returned false.
-            @response = nil
+          root_type = query.root_type
+          case query
+          when GraphQL::Query
+            ast_node = query.selected_operation
+            selections = ast_node.selections
+            object = query.root_value
+            is_eager = ast_node.operation_type == "mutation"
+            base_path = nil
+          when GraphQL::Query::Partial
+            ast_node = query.ast_nodes.first
+            selections = query.ast_nodes.map(&:selections).inject(&:+)
+            object = query.object
+            is_eager = false
+            base_path = query.path
           else
-            call_method_on_directives(:resolve, runtime_object, root_operation.directives) do # execute query level directives
-              each_gathered_selections(@response) do |selections, is_selection_array, ordered_result_keys|
-                @response.ordered_result_keys ||= ordered_result_keys
-                if is_selection_array
-                  selection_response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false, selections, is_eager, root_operation, nil, nil)
-                  selection_response.ordered_result_keys = ordered_result_keys
-                  final_response = @response
-                else
-                  selection_response = @response
-                  final_response = nil
-                end
+            raise ArgumentError, "Unexpected Runnable, can't execute: #{query.class} (#{query.inspect})"
+          end
+          object = schema.sync_lazy(object) # TODO test query partial with lazy root object
+          runtime_state = get_current_runtime_state
+          case root_type.kind.name
+          when "OBJECT"
+            object_proxy = root_type.wrap(object, context)
+            object_proxy = schema.sync_lazy(object_proxy)
+            if object_proxy.nil?
+              @response = nil
+            else
+              @response = GraphQLResultHash.new(nil, root_type, object_proxy, nil, false, selections, is_eager, ast_node, nil, nil)
+              @response.base_path = base_path
+              runtime_state.current_result = @response
+              call_method_on_directives(:resolve, object, ast_node.directives) do
+                each_gathered_selections(@response) do |selections, is_selection_array, ordered_result_keys|
+                  @response.ordered_result_keys ||= ordered_result_keys
+                  if is_selection_array
+                    selection_response = GraphQLResultHash.new(nil, root_type, object_proxy, nil, false, selections, is_eager, ast_node, nil, nil)
+                    selection_response.ordered_result_keys = ordered_result_keys
+                    final_response = @response
+                  else
+                    selection_response = @response
+                    final_response = nil
+                  end
 
-                @dataloader.append_job {
-                  evaluate_selections(
-                    selections,
-                    selection_response,
-                    final_response,
-                    nil,
+                  @dataloader.append_job {
+                    evaluate_selections(
+                      selections,
+                      selection_response,
+                      final_response,
+                      nil,
+                    )
+                  }
+                end
+              end
+            end
+          when "LIST"
+            inner_type = root_type.unwrap
+            case inner_type.kind.name
+            when "SCALAR", "ENUM"
+              result_name = ast_node.alias || ast_node.name
+              owner_type = query.field_definition.owner
+              selection_result = GraphQLResultHash.new(nil, owner_type, nil, nil, false, EmptyObjects::EMPTY_ARRAY, false, ast_node, nil, nil)
+              selection_result.base_path = base_path
+              selection_result.ordered_result_keys = [result_name]
+              runtime_state = get_current_runtime_state
+              runtime_state.current_result = selection_result
+              runtime_state.current_result_name = result_name
+              field_defn = query.field_definition
+              continue_value = continue_value(object, field_defn, false, ast_node, result_name, selection_result)
+              if HALT != continue_value
+                continue_field(continue_value, owner_type, field_defn, root_type, ast_node, nil, false, nil, nil, result_name, selection_result, false, runtime_state) # rubocop:disable Metrics/ParameterLists
+              end
+              @response = selection_result[result_name]
+            else
+              @response = GraphQLResultArray.new(nil, root_type, nil, nil, false, selections, false, ast_node, nil, nil)
+              @response.base_path = base_path
+              idx = nil
+              object.each do |inner_value|
+                idx ||= 0
+                this_idx = idx
+                idx += 1
+                @dataloader.append_job do
+                  runtime_state.current_result_name = this_idx
+                  runtime_state.current_result = @response
+                  continue_field(
+                    inner_value, root_type, nil, inner_type, nil, @response.graphql_selections, false, object_proxy,
+                    nil, this_idx, @response, false, runtime_state
                   )
-                }
+                end
+              end
+            end
+          when "SCALAR", "ENUM"
+            result_name = ast_node.alias || ast_node.name
+            owner_type = query.field_definition.owner
+            selection_result = GraphQLResultHash.new(nil, query.parent_type, nil, nil, false, EmptyObjects::EMPTY_ARRAY, false, ast_node, nil, nil)
+            selection_result.ordered_result_keys = [result_name]
+            selection_result.base_path = base_path
+            runtime_state = get_current_runtime_state
+            runtime_state.current_result = selection_result
+            runtime_state.current_result_name = result_name
+            field_defn = query.field_definition
+            continue_value = continue_value(object, field_defn, false, ast_node, result_name, selection_result)
+            if HALT != continue_value
+              continue_field(continue_value, owner_type, field_defn, query.root_type, ast_node, nil, false, nil, nil, result_name, selection_result, false, runtime_state) # rubocop:disable Metrics/ParameterLists
+            end
+            @response = selection_result[result_name]
+          when "UNION", "INTERFACE"
+            resolved_type, _resolved_obj = resolve_type(root_type, object)
+            resolved_type = schema.sync_lazy(resolved_type)
+            object_proxy = resolved_type.wrap(object, context)
+            object_proxy = schema.sync_lazy(object_proxy)
+            @response = GraphQLResultHash.new(nil, resolved_type, object_proxy, nil, false, selections, false, query.ast_nodes.first, nil, nil)
+            @response.base_path = base_path
+            each_gathered_selections(@response) do |selections, is_selection_array, ordered_result_keys|
+              @response.ordered_result_keys ||= ordered_result_keys
+              if is_selection_array == true
+                raise "This isn't supported yet"
               end
+
+              @dataloader.append_job {
+                evaluate_selections(
+                  selections,
+                  @response,
+                  nil,
+                  runtime_state,
+                )
+              }
             end
+          else
+            raise "Invariant: unsupported type kind for partial execution: #{root_type.kind.inspect} (#{root_type})"
           end
           nil
         end

data/lib/graphql/execution/interpreter.rb

@@ -26,7 +26,7 @@ module GraphQL
             query = case opts
             when Hash
               schema.query_class.new(schema, nil, **opts)
-            when GraphQL::Query
+            when GraphQL::Query, GraphQL::Query::Partial
               opts
             else
               raise "Expected Hash or GraphQL::Query, not #{opts.class} (#{opts.inspect})"

data/lib/graphql/query/partial.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    # This class is _like_ a {GraphQL::Query}, except it can run on an arbitrary path within a query string.
+    #
+    # It depends on a "parent" {Query}.
+    #
+    # During execution, it calls query-related tracing hooks but passes itself as `query:`.
+    #
+    # The {Partial} will use your {Schema.resolve_type} hook to find the right GraphQL type to use for
+    # `object` in some cases.
+    #
+    # @see Query#run_partials Run via {Query#run_partials}
+    class Partial
+      include Query::Runnable
+
+      # @param path [Array<String, Integer>] A path in `query.query_string` to start executing from
+      # @param object [Object] A starting object for execution
+      # @param query [GraphQL::Query] A full query instance that this partial is based on. Caches are shared.
+      # @param context [Hash] Extra context values to merge into `query.context`, if provided
+      def initialize(path:, object:, query:, context: nil)
+        @path = path
+        @object = object
+        @query = query
+        @schema = query.schema
+        context_vals = @query.context.to_h
+        if context
+          context_vals = context_vals.merge(context)
+        end
+        @context = GraphQL::Query::Context.new(query: self, schema: @query.schema, values: context_vals)
+        @multiplex = nil
+        @result_values = nil
+        @result = nil
+        selections = [@query.selected_operation]
+        type = @query.root_type
+        parent_type = nil
+        field_defn = nil
+        @path.each do |name_in_doc|
+          if name_in_doc.is_a?(Integer)
+            if type.list?
+              type = type.unwrap
+              next
+            else
+              raise ArgumentError, "Received path with index `#{name_in_doc}`, but type wasn't a list. Type: #{type.to_type_signature}, path: #{@path}"
+            end
+          end
+
+          next_selections = []
+          selections.each do |selection|
+            selections_to_check = []
+            selections_to_check.concat(selection.selections)
+            while (sel = selections_to_check.shift)
+              case sel
+              when GraphQL::Language::Nodes::InlineFragment
+                selections_to_check.concat(sel.selections)
+              when GraphQL::Language::Nodes::FragmentSpread
+                fragment = @query.fragments[sel.name]
+                selections_to_check.concat(fragment.selections)
+              when GraphQL::Language::Nodes::Field
+                if sel.alias == name_in_doc || sel.name == name_in_doc
+                  next_selections << sel
+                end
+              else
+                raise "Unexpected selection in partial path: #{sel.class}, #{sel.inspect}"
+              end
+            end
+          end
+
+          if next_selections.empty?
+            raise ArgumentError, "Path `#{@path.inspect}` is not present in this query. `#{name_in_doc.inspect}` was not found. Try a different path or rewrite the query to include it."
+          end
+          field_name = next_selections.first.name
+          field_defn = @schema.get_field(type, field_name, @query.context) || raise("Invariant: no field called #{field_name} on #{type.graphql_name}")
+          parent_type = type
+          type = field_defn.type
+          if type.non_null?
+            type = type.of_type
+          end
+          selections = next_selections
+        end
+        @parent_type = parent_type
+        @ast_nodes = selections
+        @root_type = type
+        @field_definition = field_defn
+        @leaf = @root_type.unwrap.kind.leaf?
+      end
+
+      def leaf?
+        @leaf
+      end
+
+      attr_reader :context, :query, :ast_nodes, :root_type, :object, :field_definition, :path, :parent_type, :schema
+
+      attr_accessor :multiplex, :result_values
+
+      class Result < GraphQL::Query::Result
+        def path
+          @query.path
+        end
+
+        # @return [GraphQL::Query::Partial]
+        def partial
+          @query
+        end
+      end
+
+      def result
+        @result ||= Result.new(query: self, values: result_values)
+      end
+
+      def current_trace
+        @query.current_trace
+      end
+
+      def types
+        @query.types
+      end
+
+      def resolve_type(...)
+        @query.resolve_type(...)
+      end
+
+      def variables
+        @query.variables
+      end
+
+      def fragments
+        @query.fragments
+      end
+
+      def valid?
+        @query.valid?
+      end
+
+      def analyzers
+        EmptyObjects::EMPTY_ARRAY
+      end
+
+      def analysis_errors=(_ignored)
+        # pass
+      end
+
+      def subscription?
+        @query.subscription?
+      end
+
+      def selected_operation
+        ast_nodes.first
+      end
+
+      def static_errors
+        @query.static_errors
+      end
+    end
+  end
+end

data/lib/graphql/query.rb

@@ -10,12 +10,47 @@ module GraphQL
     autoload :Context, "graphql/query/context"
     autoload :Fingerprint, "graphql/query/fingerprint"
     autoload :NullContext, "graphql/query/null_context"
+    autoload :Partial, "graphql/query/partial"
     autoload :Result, "graphql/query/result"
     autoload :Variables, "graphql/query/variables"
     autoload :InputValidationResult, "graphql/query/input_validation_result"
     autoload :VariableValidationError, "graphql/query/variable_validation_error"
     autoload :ValidationPipeline, "graphql/query/validation_pipeline"
 
+    # Code shared with {Partial}
+    module Runnable
+      def after_lazy(value, &block)
+        if !defined?(@runtime_instance)
+          @runtime_instance = context.namespace(:interpreter_runtime)[:runtime]
+        end
+
+        if @runtime_instance
+          @runtime_instance.minimal_after_lazy(value, &block)
+        else
+          @schema.after_lazy(value, &block)
+        end
+      end
+
+      # Node-level cache for calculating arguments. Used during execution and query analysis.
+      # @param ast_node [GraphQL::Language::Nodes::AbstractNode]
+      # @param definition [GraphQL::Schema::Field]
+      # @param parent_object [GraphQL::Schema::Object]
+      # @return [Hash{Symbol => Object}]
+      def arguments_for(ast_node, definition, parent_object: nil)
+        arguments_cache.fetch(ast_node, definition, parent_object)
+      end
+
+      def arguments_cache
+        @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
+      end
+
+      # @api private
+      def handle_or_reraise(err)
+        @schema.handle_or_reraise(context, err)
+      end
+    end
+
+    include Runnable
     class OperationNameMissingError < GraphQL::ExecutionError
       def initialize(name)
         msg = if name.nil?
@@ -198,19 +233,10 @@ module GraphQL
     # @return [GraphQL::Execution::Lookahead]
     def lookahead
       @lookahead ||= begin
-        ast_node = selected_operation
-        if ast_node.nil?
+        if selected_operation.nil?
           GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
         else
-          root_type = case ast_node.operation_type
-          when nil, "query"
-            types.query_root # rubocop:disable Development/ContextIsPassedCop
-          when "mutation"
-            types.mutation_root # rubocop:disable Development/ContextIsPassedCop
-          when "subscription"
-            types.subscription_root # rubocop:disable Development/ContextIsPassedCop
-          end
-          GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [ast_node])
+          GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [selected_operation])
         end
       end
     end
@@ -236,6 +262,18 @@ module GraphQL
       with_prepared_ast { @operations }
     end
 
+    # Run subtree partials of this query and return their results.
+    # Each partial is identified with a `path:` and `object:`
+    # where the path references a field in the AST and the object will be treated
+    # as the return value from that field. Subfields of the field named by `path`
+    # will be executed with `object` as the starting point
+    # @param partials_hashes [Array<Hash{Symbol => Object}>] Hashes with `path:` and `object:` keys
+    # @return [Array<GraphQL::Query::Result>]
+    def run_partials(partials_hashes)
+      partials = partials_hashes.map { |partial_options| Partial.new(query: self, **partial_options) }
+      Execution::Interpreter.run_all(@schema, partials, context: @context)
+    end
+
     # Get the result for this query, executing it once
     # @return [GraphQL::Query::Result] A Hash-like GraphQL response, with `"data"` and/or `"errors"` keys
     def result
@@ -278,19 +316,6 @@ module GraphQL
       end
     end
 
-    # Node-level cache for calculating arguments. Used during execution and query analysis.
-    # @param ast_node [GraphQL::Language::Nodes::AbstractNode]
-    # @param definition [GraphQL::Schema::Field]
-    # @param parent_object [GraphQL::Schema::Object]
-    # @return [Hash{Symbol => Object}]
-    def arguments_for(ast_node, definition, parent_object: nil)
-      arguments_cache.fetch(ast_node, definition, parent_object)
-    end
-
-    def arguments_cache
-      @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
-    end
-
     # A version of the given query string, with:
     # - Variables inlined to the query
     # - Strings replaced with `<REDACTED>`
@@ -357,17 +382,21 @@ module GraphQL
 
     def root_type_for_operation(op_type)
       case op_type
-      when "query"
+      when "query", nil
         types.query_root # rubocop:disable Development/ContextIsPassedCop
       when "mutation"
         types.mutation_root # rubocop:disable Development/ContextIsPassedCop
       when "subscription"
         types.subscription_root # rubocop:disable Development/ContextIsPassedCop
       else
-        raise ArgumentError, "unexpected root type name: #{op_type.inspect}; expected 'query', 'mutation', or 'subscription'"
+        raise ArgumentError, "unexpected root type name: #{op_type.inspect}; expected nil, 'query', 'mutation', or 'subscription'"
       end
     end
 
+    def root_type
+      root_type_for_operation(selected_operation.operation_type)
+    end
+
     def types
       @visibility_profile || warden.visibility_profile
     end
@@ -400,23 +429,6 @@ module GraphQL
       with_prepared_ast { @subscription }
     end
 
-    # @api private
-    def handle_or_reraise(err)
-      schema.handle_or_reraise(context, err)
-    end
-
-    def after_lazy(value, &block)
-      if !defined?(@runtime_instance)
-        @runtime_instance = context.namespace(:interpreter_runtime)[:runtime]
-      end
-
-      if @runtime_instance
-        @runtime_instance.minimal_after_lazy(value, &block)
-      else
-        @schema.after_lazy(value, &block)
-      end
-    end
-
     attr_reader :logger
 
     private

data/lib/graphql/schema/input_object.rb

@@ -176,30 +176,33 @@ module GraphQL
             return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
           end
 
-          # Inject missing required arguments
-          missing_required_inputs = ctx.types.arguments(self).reduce({}) do |m, (argument)|
-            if !input.key?(argument.graphql_name) && argument.type.non_null? && !argument.default_value? && types.argument(self, argument.graphql_name)
-              m[argument.graphql_name] = nil
-            end
-
-            m
-          end
 
           result = nil
-          [input, missing_required_inputs].each do |args_to_validate|
-            args_to_validate.each do |argument_name, value|
-              argument = types.argument(self, argument_name)
-              # Items in the input that are unexpected
-              if argument.nil?
-                result ||= Query::InputValidationResult.new
-                result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
-              else
-                # Items in the input that are expected, but have invalid values
-                argument_result = argument.type.validate_input(value, ctx)
+
+
+          input.each do |argument_name, value|
+            argument = types.argument(self, argument_name)
+            # Items in the input that are unexpected
+            if argument.nil?
+              result ||= Query::InputValidationResult.new
+              result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
+            else
+              # Items in the input that are expected, but have invalid values
+              argument_result = argument.type.validate_input(value, ctx)
+              if !argument_result.valid?
                 result ||= Query::InputValidationResult.new
-                if !argument_result.valid?
-                  result.merge_result!(argument_name, argument_result)
-                end
+                result.merge_result!(argument_name, argument_result)
+              end
+            end
+          end
+
+          # Check for missing non-null arguments
+          ctx.types.arguments(self).each do |argument|
+            if !input.key?(argument.graphql_name) && argument.type.non_null? && !argument.default_value?
+              result ||= Query::InputValidationResult.new
+              argument_result = argument.type.validate_input(nil, ctx)
+              if !argument_result.valid?
+                result.merge_result!(argument.graphql_name, argument_result)
               end
             end
           end

data/lib/graphql/schema/visibility.rb

@@ -12,7 +12,7 @@ module GraphQL
       # @param profiles [Hash<Symbol => Hash>] A hash of `name => context` pairs for preloading visibility profiles
       # @param preload [Boolean] if `true`, load the default schema profile and all named profiles immediately (defaults to `true` for `Rails.env.production?`)
       # @param migration_errors [Boolean] if `true`, raise an error when `Visibility` and `Warden` return different results
-      def self.use(schema, dynamic: false, profiles: EmptyObjects::EMPTY_HASH, preload: (defined?(Rails) ? Rails.env.production? : nil), migration_errors: false)
+      def self.use(schema, dynamic: false, profiles: EmptyObjects::EMPTY_HASH, preload: (defined?(Rails.env) ? Rails.env.production? : nil), migration_errors: false)
         profiles&.each { |name, ctx|
           ctx[:visibility_profile] = name
           ctx.freeze

data/lib/graphql/schema.rb

@@ -1189,7 +1189,7 @@ module GraphQL
       # @param context [GraphQL::Query::Context] The query context for the currently-executing query
       # @return [Class<GraphQL::Schema::Object] The Object type definition to use for `obj`
       def resolve_type(abstract_type, application_object, context)
-        raise GraphQL::RequiredImplementationMissingError, "#{self.name}.resolve_type(abstract_type, application_object, context) must be implemented to use Union types, Interface types, or `loads:` (tried to resolve: #{abstract_type.name})"
+        raise GraphQL::RequiredImplementationMissingError, "#{self.name}.resolve_type(abstract_type, application_object, context) must be implemented to use Union types, Interface types, `loads:`, or `run_partials` (tried to resolve: #{abstract_type.name})"
       end
       # rubocop:enable Lint/DuplicateMethods
 

data/lib/graphql/tracing/notifications_trace.rb

@@ -137,7 +137,9 @@ module GraphQL
 
       def dataloader_fiber_resume(source)
         prev_ev = Fiber[PREVIOUS_EV_KEY]
-        begin_notifications_event(prev_ev.name, prev_ev.payload)
+        if prev_ev
+          begin_notifications_event(prev_ev.name, prev_ev.payload)
+        end
         super
       end
 

data/lib/graphql/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.5.4
+  version: 2.5.6
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2025-04-18 00:00:00.000000000 Z
+date: 2025-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -163,6 +163,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -536,6 +550,7 @@ files:
 - lib/graphql/query/fingerprint.rb
 - lib/graphql/query/input_validation_result.rb
 - lib/graphql/query/null_context.rb
+- lib/graphql/query/partial.rb
 - lib/graphql/query/result.rb
 - lib/graphql/query/validation_pipeline.rb
 - lib/graphql/query/variable_validation_error.rb
@@ -801,7 +816,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.6
+rubygems_version: 3.6.8
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby
 test_files: []