graphql 1.11.11 → 1.12.0

data/lib/graphql/schema/field.rb

@@ -15,8 +15,11 @@ module GraphQL
       include GraphQL::Schema::Member::HasArguments
       include GraphQL::Schema::Member::HasAstNode
       include GraphQL::Schema::Member::HasPath
+      include GraphQL::Schema::Member::HasValidators
       extend GraphQL::Schema::FindInheritedValue
       include GraphQL::Schema::FindInheritedValue::EmptyObjects
+      include GraphQL::Schema::Member::HasDirectives
+      include GraphQL::Schema::Member::HasDeprecationReason
 
       # @return [String] the GraphQL name for this field, camelized unless `camelize: false` is provided
       attr_reader :name
@@ -24,9 +27,6 @@ module GraphQL
 
       attr_writer :description
 
-      # @return [String, nil] If present, the field is marked as deprecated with this documentation
-      attr_accessor :deprecation_reason
-
       # @return [Symbol] Method or hash key on the underlying object to look up
       attr_reader :method_sym
 
@@ -82,10 +82,10 @@ module GraphQL
       # @see {.initialize} for other options
       def self.from_options(name = nil, type = nil, desc = nil, resolver: nil, mutation: nil, subscription: nil,**kwargs, &block)
         if kwargs[:field]
-          if kwargs[:field] == GraphQL::Relay::Node.field
+          if kwargs[:field].is_a?(GraphQL::Field) && kwargs[:field] == GraphQL::Types::Relay::NodeField.graphql_definition
             warn("Legacy-style `GraphQL::Relay::Node.field` is being added to a class-based type. See `GraphQL::Types::Relay::NodeField` for a replacement.")
             return GraphQL::Types::Relay::NodeField
-          elsif kwargs[:field] == GraphQL::Relay::Node.plural_field
+          elsif kwargs[:field].is_a?(GraphQL::Field) && kwargs[:field] == GraphQL::Types::Relay::NodesField.graphql_definition
             warn("Legacy-style `GraphQL::Relay::Node.plural_field` is being added to a class-based type. See `GraphQL::Types::Relay::NodesField` for a replacement.")
             return GraphQL::Types::Relay::NodesField
           end
@@ -199,11 +199,14 @@ module GraphQL
       # @param scope [Boolean] If true, the return type's `.scope_items` method will be called on the return value
       # @param subscription_scope [Symbol, String] A key in `context` which will be used to scope subscription payloads
       # @param extensions [Array<Class, Hash<Class => Object>>] Named extensions to apply to this field (see also {#extension})
+      # @param directives [Hash{Class => Hash}] Directives to apply to this field
       # @param trace [Boolean] If true, a {GraphQL::Tracing} tracer will measure this scalar field
       # @param broadcastable [Boolean] Whether or not this field can be distributed in subscription broadcasts
       # @param ast_node [Language::Nodes::FieldDefinition, nil] If this schema was parsed from definition, this AST node defined the field
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
-      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, &definition_block)
+      # @param validates [Array<Hash>] Configurations for validating this field
+      # @param legacy_edge_class [Class, nil] (DEPRECATED) If present, pass this along to the legacy field definition
+      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, legacy_edge_class: nil, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -222,7 +225,6 @@ module GraphQL
         name_s = -name.to_s
         @underscored_name = -Member::BuildType.underscore(name_s)
         @name = -(camelize ? Member::BuildType.camelize(name_s) : name_s)
-        NameValidator.validate!(@name)
         @description = description
         if field.is_a?(GraphQL::Schema::Field)
           raise ArgumentError, "Instead of passing a field as `field:`, use `add_field(field)` to add an already-defined field."
@@ -231,7 +233,7 @@ module GraphQL
         end
         @function = function
         @resolve = resolve
-        @deprecation_reason = deprecation_reason
+        self.deprecation_reason = deprecation_reason
 
         if method && hash_key
           raise ArgumentError, "Provide `method:` _or_ `hash_key:`, not both. (called with: `method: #{method.inspect}, hash_key: #{hash_key.inspect}`)"
@@ -270,6 +272,7 @@ module GraphQL
         @relay_nodes_field = relay_nodes_field
         @ast_node = ast_node
         @method_conflict_warning = method_conflict_warning
+        @legacy_edge_class = legacy_edge_class
 
         arguments.each do |name, arg|
           if arg.is_a?(Hash)
@@ -298,6 +301,14 @@ module GraphQL
           self.extension(connection_extension)
         end
 
+        if directives.any?
+          directives.each do |(dir_class, options)|
+            self.directive(dir_class, **options)
+          end
+        end
+
+        self.validates(validates)
+
         if definition_block
           if definition_block.arity == 1
             yield self
@@ -439,8 +450,8 @@ module GraphQL
           field_defn.description = @description
         end
 
-        if @deprecation_reason
-          field_defn.deprecation_reason = @deprecation_reason
+        if self.deprecation_reason
+          field_defn.deprecation_reason = self.deprecation_reason
         end
 
         if @resolver_class
@@ -462,6 +473,10 @@ module GraphQL
           field_defn.relay_nodes_field = @relay_nodes_field
         end
 
+        if @legacy_edge_class
+          field_defn.edge_class = @legacy_edge_class
+        end
+
         field_defn.resolve = self.method(:resolve_field)
         field_defn.connection = connection?
         field_defn.connection_max_page_size = max_page_size
@@ -581,6 +596,9 @@ module GraphQL
         begin
           # Unwrap the GraphQL object to get the application object.
           application_object = object.object
+
+          Schema::Validator.validate!(validators, application_object, ctx, args)
+
           ctx.schema.after_lazy(self.authorized?(application_object, args, ctx)) do |is_authorized|
             if is_authorized
               public_send_field(object, args, ctx)

data/lib/graphql/schema/input_object.rb

@@ -7,6 +7,7 @@ module GraphQL
       extend GraphQL::Schema::Member::HasArguments
       extend GraphQL::Schema::Member::HasArguments::ArgumentObjectLoader
       extend GraphQL::Schema::Member::ValidatesInput
+      extend GraphQL::Schema::Member::HasValidators
 
       include GraphQL::Dig
 
@@ -37,14 +38,15 @@ module GraphQL
                 load_application_object(arg_defn, loads, value, context)
               end
               maybe_lazies << context.schema.after_lazy(loaded_value) do |loaded_value|
-                @ruby_style_hash[ruby_kwargs_key] = loaded_value
+                overwrite_argument(ruby_kwargs_key, loaded_value)
               end
             end
 
             # Weirdly, procs are applied during coercion, but not methods.
             # Probably because these methods require a `self`.
             if arg_defn.prepare.is_a?(Symbol) || context.nil? || !context.interpreter?
-              @ruby_style_hash[ruby_kwargs_key] = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key])
+              prepared_value = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key])
+              overwrite_argument(ruby_kwargs_key, prepared_value)
             end
           end
         end
@@ -74,6 +76,9 @@ module GraphQL
       def prepare
         if context
           context.schema.after_any_lazies(@maybe_lazies) do
+            object = context[:current_object]
+            # Pass this object's class with `as` so that messages are rendered correctly from inherited validators
+            Schema::Validator.validate!(self.class.validators, object, context, @ruby_style_hash, as: self.class)
             self
           end
         else
@@ -125,8 +130,12 @@ module GraphQL
         def argument(*args, **kwargs, &block)
           argument_defn = super(*args, **kwargs, &block)
           # Add a method access
-          define_accessor_method(argument_defn.keyword)
-          argument_defn
+          method_name = argument_defn.keyword
+          class_eval <<-RUBY, __FILE__, __LINE__
+            def #{method_name}
+              self[#{method_name.inspect}]
+            end
+          RUBY
         end
 
         def to_graphql
@@ -164,17 +173,10 @@ module GraphQL
             return result
           end
 
-          input = begin
-            input.to_h
-          rescue
-            begin
-              # Handle ActionController::Parameters:
-              input.to_unsafe_h
-            rescue
-              # We're not sure it'll act like a hash, so reject it:
-              result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
-              return result
-            end
+          if !(input.respond_to?(:to_h) || input.respond_to?(:to_unsafe_h))
+            # We're not sure it'll act like a hash, so reject it:
+            result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
+            return result
           end
 
           # Inject missing required arguments
@@ -186,16 +188,19 @@ module GraphQL
             m
           end
 
-          input.merge(missing_required_inputs).each do |argument_name, value|
-            argument = warden.get_argument(self, argument_name)
-            # Items in the input that are unexpected
-            unless argument
-              result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
-              next
+
+          [input, missing_required_inputs].each do |args_to_validate|
+            args_to_validate.each do |argument_name, value|
+              argument = warden.get_argument(self, argument_name)
+              # Items in the input that are unexpected
+              unless argument
+                result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
+                next
+              end
+              # Items in the input that are expected, but have invalid values
+              argument_result = argument.type.validate_input(value, ctx)
+              result.merge_result!(argument_name, argument_result) unless argument_result.valid?
             end
-            # Items in the input that are expected, but have invalid values
-            argument_result = argument.type.validate_input(value, ctx)
-            result.merge_result!(argument_name, argument_result) unless argument_result.valid?
           end
 
           result
@@ -235,13 +240,16 @@ module GraphQL
 
           result
         end
+      end
 
-        private
+      private
 
-        def define_accessor_method(method_name)
-          define_method(method_name) { self[method_name] }
-          alias_method(method_name, method_name)
+      def overwrite_argument(key, value)
+        # Argument keywords come in frozen from the interpreter, dup them before modifying them.
+        if @ruby_style_hash.frozen?
+          @ruby_style_hash = @ruby_style_hash.dup
         end
+        @ruby_style_hash[key] = value
       end
     end
   end

data/lib/graphql/schema/interface.rb

@@ -15,6 +15,7 @@ module GraphQL
         include GraphQL::Schema::Member::Scoped
         include GraphQL::Schema::Member::HasAstNode
         include GraphQL::Schema::Member::HasUnresolvedTypeError
+        include GraphQL::Schema::Member::HasDirectives
 
         # Methods defined in this block will be:
         # - Added as class methods to this interface

data/lib/graphql/schema/member/base_dsl_methods.rb

@@ -19,6 +19,7 @@ module GraphQL
         # @return [String]
         def graphql_name(new_name = nil)
           if new_name
+            GraphQL::NameValidator.validate!(new_name)
             @graphql_name = new_name
           else
             overridden_graphql_name || default_graphql_name

data/lib/graphql/schema/member/build_type.rb

@@ -60,11 +60,11 @@ module GraphQL
               parse_type(type_expr.first, null: false)
             when 2
               inner_type, nullable_option = type_expr
-              if nullable_option.keys != [:null] || nullable_option.values != [true]
+              if nullable_option.keys != [:null] || (nullable_option[:null] != true && nullable_option[:null] != false)
                 raise ArgumentError, LIST_TYPE_ERROR
               end
               list_type = true
-              parse_type(inner_type, null: true)
+              parse_type(inner_type, null: nullable_option[:null])
             else
               raise ArgumentError, LIST_TYPE_ERROR
             end
@@ -75,7 +75,7 @@ module GraphQL
             if type_expr.respond_to?(:graphql_definition)
               type_expr
             else
-              # Eg `String` => GraphQL::STRING_TYPE
+              # Eg `String` => GraphQL::Types::String
               parse_type(type_expr.name, null: true)
             end
           when Proc

data/lib/graphql/schema/member/has_arguments.rb

@@ -89,7 +89,7 @@ module GraphQL
           arg_defns = self.arguments
 
           if arg_defns.empty?
-            GraphQL::Execution::Interpreter::Arguments.new(argument_values: nil)
+            GraphQL::Execution::Interpreter::Arguments::EMPTY
           else
             argument_values = {}
             arg_lazies = arg_defns.map do |arg_name, arg_defn|
@@ -111,24 +111,28 @@ module GraphQL
               if has_value
                 loads = arg_defn.loads
                 loaded_value = nil
+                coerced_value = context.schema.error_handler.with_error_handling(context) do
+                  arg_defn.type.coerce_input(value, context)
+                end
+
+                # TODO this should probably be inside after_lazy
                 if loads && !arg_defn.from_resolver?
                   loaded_value = if arg_defn.type.list?
-                    loaded_values = value.map { |val| load_application_object(arg_defn, loads, val, context) }
+                    loaded_values = coerced_value.map { |val| load_application_object(arg_defn, loads, val, context) }
                     context.schema.after_any_lazies(loaded_values) { |result| result }
                   else
-                    load_application_object(arg_defn, loads, value, context)
+                    load_application_object(arg_defn, loads, coerced_value, context)
                   end
                 end
 
                 coerced_value = if loaded_value
                   loaded_value
                 else
-                  context.schema.error_handler.with_error_handling(context) do
-                    arg_defn.type.coerce_input(value, context)
-                  end
+                  coerced_value
                 end
 
                 context.schema.after_lazy(coerced_value) do |coerced_value|
+                  validate_directive_argument(arg_defn, coerced_value)
                   prepared_value = context.schema.error_handler.with_error_handling(context) do
                     arg_defn.prepare_value(parent_object, coerced_value, context: context)
                   end
@@ -140,6 +144,9 @@ module GraphQL
                     default_used: default_used,
                   )
                 end
+              else
+                # has_value is false
+                validate_directive_argument(arg_defn, nil)
               end
             end
 
@@ -151,6 +158,17 @@ module GraphQL
           end
         end
 
+        # Usually, this is validated statically by RequiredArgumentsArePresent,
+        # but not for directives.
+        # TODO apply static validations on schema definitions?
+        def validate_directive_argument(arg_defn, value)
+          if arg_defn.owner.is_a?(Class) && arg_defn.owner < GraphQL::Schema::Directive
+            if value.nil? && arg_defn.type.non_null?
+              raise ArgumentError, "#{arg_defn.path} is required, but no value was given"
+            end
+          end
+        end
+
         def arguments_statically_coercible?
           return @arguments_statically_coercible if defined?(@arguments_statically_coercible)
 

data/lib/graphql/schema/member/has_deprecation_reason.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module HasDeprecationReason
+        # @return [String, nil] Explains why this member was deprecated (if present, this will be marked deprecated in introspection)
+        def deprecation_reason
+          dir = self.directives.find { |d| d.is_a?(GraphQL::Schema::Directive::Deprecated) }
+          dir && dir.arguments[:reason]
+        end
+
+        # Set the deprecation reason for this member, or remove it by assigning `nil`
+        # @param text [String, nil]
+        def deprecation_reason=(text)
+          if text.nil?
+            remove_directive(GraphQL::Schema::Directive::Deprecated)
+          else
+            directive(GraphQL::Schema::Directive::Deprecated, reason: text)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/member/has_directives.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module HasDirectives
+        # Create an instance of `dir_class` for `self`, using `options`.
+        #
+        # It removes a previously-attached instance of `dir_class`, if there is one.
+        #
+        # @return [void]
+        def directive(dir_class, **options)
+          @own_directives ||= []
+          remove_directive(dir_class)
+          @own_directives << dir_class.new(self, **options)
+          nil
+        end
+
+        # Remove an attached instance of `dir_class`, if there is one
+        # @param dir_class [Class<GraphQL::Schema::Directive>]
+        # @return [viod]
+        def remove_directive(dir_class)
+          @own_directives && @own_directives.reject! { |d| d.is_a?(dir_class) }
+          nil
+        end
+
+        NO_DIRECTIVES = [].freeze
+
+        def directives
+          case self
+          when Class
+            inherited_directives = if superclass.respond_to?(:directives)
+              superclass.directives
+            else
+              NO_DIRECTIVES
+            end
+            if inherited_directives.any? && @own_directives
+              dirs = []
+              merge_directives(dirs, inherited_directives)
+              merge_directives(dirs, @own_directives)
+              dirs
+            elsif @own_directives
+              @own_directives
+            elsif inherited_directives.any?
+              inherited_directives
+            else
+              NO_DIRECTIVES
+            end
+          when Module
+            dirs = nil
+            self.ancestors.reverse_each do |ancestor|
+              if ancestor.respond_to?(:own_directives) &&
+                  (anc_dirs = ancestor.own_directives).any?
+                dirs ||= []
+                merge_directives(dirs, anc_dirs)
+              end
+            end
+            if own_directives
+              dirs ||= []
+              merge_directives(dirs, own_directives)
+            end
+            dirs || NO_DIRECTIVES
+          when HasDirectives
+            @own_directives || NO_DIRECTIVES
+          else
+            raise "Invariant: how could #{self} not be a Class, Module, or instance of HasDirectives?"
+          end
+        end
+
+        protected
+
+        def own_directives
+          @own_directives
+        end
+
+        private
+
+        # Modify `target` by adding items from `dirs` such that:
+        # - Any name conflict is overriden by the incoming member of `dirs`
+        # - Any other member of `dirs` is appended
+        # @param target [Array<GraphQL::Schema::Directive>]
+        # @param dirs [Array<GraphQL::Schema::Directive>]
+        # @return [void]
+        def merge_directives(target, dirs)
+          dirs.each do |dir|
+            if (idx = target.find_index { |d| d.graphql_name == dir.graphql_name })
+              target.slice!(idx)
+              target.insert(idx, dir)
+            else
+              target << dir
+            end
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/member/has_validators.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      module HasValidators
+        include Schema::FindInheritedValue::EmptyObjects
+
+        # Build {GraphQL::Schema::Validator}s based on the given configuration
+        # and use them for this schema member
+        # @param validation_config [Hash{Symbol => Hash}]
+        # @return [void]
+        def validates(validation_config)
+          new_validators = GraphQL::Schema::Validator.from_config(self, validation_config)
+          @own_validators ||= []
+          @own_validators.concat(new_validators)
+          nil
+        end
+
+        # @return [Array<GraphQL::Schema::Validator>]
+        def validators
+          own_validators = @own_validators || EMPTY_ARRAY
+          if self.is_a?(Class) && superclass.respond_to?(:validators) && (inherited_validators = superclass.validators).any?
+            inherited_validators + own_validators
+          else
+            own_validators
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/member/type_system_helpers.rb

@@ -30,7 +30,7 @@ module GraphQL
 
         # @return [GraphQL::TypeKinds::TypeKind]
         def kind
-          raise GraphQL::RequiredImplementationMissingError
+          raise GraphQL::RequiredImplementationMissingError, "No `.kind` defined for #{self}"
         end
       end
     end

data/lib/graphql/schema/member.rb

@@ -4,8 +4,11 @@ require 'graphql/schema/member/base_dsl_methods'
 require 'graphql/schema/member/cached_graphql_definition'
 require 'graphql/schema/member/graphql_type_names'
 require 'graphql/schema/member/has_ast_node'
+require 'graphql/schema/member/has_directives'
+require 'graphql/schema/member/has_deprecation_reason'
 require 'graphql/schema/member/has_path'
 require 'graphql/schema/member/has_unresolved_type_error'
+require 'graphql/schema/member/has_validators'
 require 'graphql/schema/member/relay_shortcuts'
 require 'graphql/schema/member/scoped'
 require 'graphql/schema/member/type_system_helpers'
@@ -30,6 +33,7 @@ module GraphQL
       extend RelayShortcuts
       extend HasPath
       extend HasAstNode
+      extend HasDirectives
     end
   end
 end

data/lib/graphql/schema/object.rb

@@ -14,6 +14,17 @@ module GraphQL
       # @return [GraphQL::Query::Context] the context instance for this query
       attr_reader :context
 
+      # @return [GraphQL::Dataloader]
+      def dataloader
+        context.dataloader
+      end
+
+      # Call this in a field method to return a value that should be returned to the client
+      # without any further handling by GraphQL.
+      def raw_value(obj)
+        GraphQL::Execution::Interpreter::RawValue.new(obj)
+      end
+
       class << self
         # This is protected so that we can be sure callers use the public method, {.authorized_new}
         # @see authorized_new to make instances

data/lib/graphql/schema/printer.rb

@@ -59,14 +59,15 @@ module GraphQL
 
       # Return the GraphQL schema string for the introspection type system
       def self.print_introspection_schema
-        query_root = ObjectType.define(name: "Root") do
-          field :throwaway_field, types.String
+        query_root = Class.new(GraphQL::Schema::Object) do
+          graphql_name "Root"
+          field :throwaway_field, String, null: true
         end
-        schema = GraphQL::Schema.define(query: query_root)
+        schema = Class.new(GraphQL::Schema) { query(query_root) }
 
         introspection_schema_ast = GraphQL::Language::DocumentFromSchemaDefinition.new(
           schema,
-          except: ->(member, _) { member.name == "Root" },
+          except: ->(member, _) { member.graphql_name == "Root" },
           include_introspection_types: true,
           include_built_in_directives: true,
         ).document

data/lib/graphql/schema/resolver/has_payload_type.rb

@@ -44,6 +44,8 @@ module GraphQL
           end
         end
 
+        NO_INTERFACES = [].freeze
+
         private
 
         # Build a subclass of {.object_class} based on `self`.

data/lib/graphql/schema/resolver.rb

@@ -24,6 +24,7 @@ module GraphQL
       # Really we only need description from here, but:
       extend Schema::Member::BaseDSLMethods
       extend GraphQL::Schema::Member::HasArguments
+      extend GraphQL::Schema::Member::HasValidators
       include Schema::Member::HasPath
       extend Schema::Member::HasPath
 
@@ -49,6 +50,11 @@ module GraphQL
       # @return [GraphQL::Query::Context]
       attr_reader :context
 
+      # @return [GraphQL::Dataloader]
+      def dataloader
+        context.dataloader
+      end
+
       # @return [GraphQL::Schema::Field]
       attr_reader :field
 
@@ -80,6 +86,7 @@ module GraphQL
             load_arguments_val = load_arguments(args)
             context.schema.after_lazy(load_arguments_val) do |loaded_args|
               @prepared_arguments = loaded_args
+              Schema::Validator.validate!(self.class.validators, object, context, loaded_args, as: @field)
               # Then call `authorized?`, which may raise or may return a lazy object
               authorized_val = if loaded_args.any?
                 authorized?(**loaded_args)

data/lib/graphql/schema/subscription.rb

@@ -25,6 +25,22 @@ module GraphQL
         @mode = context.query.subscription_update? ? :update : :subscribe
       end
 
+      def resolve_with_support(**args)
+        result = nil
+        unsubscribed = true
+        catch :graphql_subscription_unsubscribed do
+          result = super
+          unsubscribed = false
+        end
+
+
+        if unsubscribed
+          context.skip
+        else
+          result
+        end
+      end
+
       # Implement the {Resolve} API
       def resolve(**args)
         # Dispatch based on `@mode`, which will raise a `NoMethodError` if we ever
@@ -55,7 +71,8 @@ module GraphQL
       def resolve_update(**args)
         ret_val = args.any? ? update(**args) : update
         if ret_val == :no_update
-          throw :graphql_no_subscription_update
+          context.namespace(:subscriptions)[:no_update] = true
+          context.skip
         else
           ret_val
         end
@@ -80,6 +97,7 @@ module GraphQL
 
       # Call this to halt execution and remove this subscription from the system
       def unsubscribe
+        context.namespace(:subscriptions)[:unsubscribed] = true
         throw :graphql_subscription_unsubscribed
       end
 

data/lib/graphql/schema/timeout_middleware.rb

@@ -23,6 +23,8 @@ module GraphQL
     #    Bugsnag.notify(timeout_error, {query_string: query_ctx.query.query_string})
     #   end
     #
+    # @api deprecated
+    # @see Schema::Timeout
     class TimeoutMiddleware
       # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
       def initialize(max_seconds:, context_key: nil, &block)