graphql 2.5.9 → 2.5.26

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

@@ -14,29 +14,52 @@ module GraphQL
           cls.extend(ClassConfigured)
         end
 
-        # @see {GraphQL::Schema::Argument#initialize} for parameters
-        # @return [GraphQL::Schema::Argument] An instance of {argument_class}, created from `*args`
-        def argument(*args, **kwargs, &block)
-          kwargs[:owner] = self
-          loads = kwargs[:loads]
-          if loads
-            name = args[0]
-            name_as_string = name.to_s
-
-            inferred_arg_name = case name_as_string
+        # @param arg_name [Symbol] The underscore-cased name of this argument, `name:` keyword also accepted
+        # @param type_expr The GraphQL type of this argument; `type:` keyword also accepted
+        # @param desc [String] Argument description, `description:` keyword also accepted
+        # @option kwargs [Boolean, :nullable] :required if true, this argument is non-null; if false, this argument is nullable. If `:nullable`, then the argument must be provided, though it may be `null`.
+        # @option kwargs [String] :description Positional argument also accepted
+        # @option kwargs [Class, Array<Class>] :type Input type; positional argument also accepted
+        # @option kwargs [Symbol] :name positional argument also accepted
+        # @option kwargs [Object] :default_value
+        # @option kwargs [Class, Array<Class>] :loads A GraphQL type to load for the given ID when one is present
+        # @option kwargs [Symbol] :as Override the keyword name when passed to a method
+        # @option kwargs [Symbol] :prepare A method to call to transform this argument's valuebefore sending it to field resolution
+        # @option kwargs [Boolean] :camelize if true, the name will be camelized when building the schema
+        # @option kwargs [Boolean] :from_resolver if true, a Resolver class defined this argument
+        # @option kwargs [Hash{Class => Hash}] :directives
+        # @option kwargs [String] :deprecation_reason
+        # @option kwargs [String] :comment Private, used by GraphQL-Ruby when parsing GraphQL schema files
+        # @option kwargs [GraphQL::Language::Nodes::InputValueDefinition] :ast_node Private, used by GraphQL-Ruby when parsing schema files
+        # @option kwargs [Hash, nil] :validates Options for building validators, if any should be applied
+        # @option kwargs [Boolean] :replace_null_with_default if `true`, incoming values of `null` will be replaced with the configured `default_value`
+        # @param definition_block [Proc] Called with the newly-created {Argument}
+        # @param kwargs [Hash] Keywords for defining an argument. Any keywords not documented here must be handled by your base Argument class.
+        # @return [GraphQL::Schema::Argument] An instance of {argument_class} created from these arguments
+        def argument(arg_name = nil, type_expr = nil, desc = nil, **kwargs, &definition_block)
+          if kwargs[:loads]
+            loads_name = arg_name || kwargs[:name]
+            loads_name_as_string = loads_name.to_s
+
+            inferred_arg_name = case loads_name_as_string
             when /_id$/
-              name_as_string.sub(/_id$/, "").to_sym
+              loads_name_as_string.sub(/_id$/, "").to_sym
             when /_ids$/
-              name_as_string.sub(/_ids$/, "")
+              loads_name_as_string.sub(/_ids$/, "")
                 .sub(/([^s])$/, "\\1s")
                 .to_sym
             else
-              name
+              loads_name
             end
 
             kwargs[:as] ||= inferred_arg_name
           end
-          arg_defn = self.argument_class.new(*args, **kwargs, &block)
+          kwargs[:owner] = self
+          arg_defn = self.argument_class.new(
+            arg_name, type_expr, desc,
+            **kwargs,
+            &definition_block
+          )
           add_argument(arg_defn)
           arg_defn
         end
@@ -413,6 +436,12 @@ module GraphQL
             end
           end
 
+          # Called when an argument's `loads:` configuration fails to fetch an application object.
+          # By default, this method raises the given error, but you can override it to handle failures differently.
+          #
+          # @param err [GraphQL::LoadApplicationObjectFailedError] The error that occurred
+          # @return [Object, nil] If a value is returned, it will be used instead of the failed load
+          # @api public
           def load_application_object_failed(err)
             raise err
           end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      module HasAuthorization
+        def self.included(child_class)
+          child_class.include(InstanceConfigured)
+        end
+
+        def self.extended(child_class)
+          child_class.extend(ClassConfigured)
+          child_class.class_exec do
+            @authorizes = false
+          end
+        end
+
+        def authorized?(object, context)
+          true
+        end
+
+        module InstanceConfigured
+          def authorizes?(context)
+            raise RequiredImplementationMissingError, "#{self.class} must implement #authorizes?(context)"
+          end
+        end
+
+        module ClassConfigured
+          def authorizes?(context)
+            method(:authorized?).owner != GraphQL::Schema::Member::HasAuthorization
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -20,6 +20,23 @@ module GraphQL
           dataloader.with(source_class, *source_args).load(load_key)
         end
 
+        # A shortcut method for loading many keys from a source.
+        # Identical to `dataloader.with(source_class, *source_args).load_all(load_keys)`
+        #
+        # @example
+        #   field :score, Integer, resolve_batch: true
+        #
+        #   def self.score(posts)
+        #     dataload_all(PostScoreSource, posts.map(&:id))
+        #   end
+        #
+        # @param source_class [Class<GraphQL::Dataloader::Source>]
+        # @param source_args [Array<Object>] Any extra parameters defined in `source_class`'s `initialize` method
+        # @param load_keys [Array<Object>] The keys to look up using `def fetch`
+        def dataload_all(source_class, *source_args, load_keys)
+          dataloader.with(source_class, *source_args).load_all(load_keys)
+        end
+
         # Find an object with ActiveRecord via {Dataloader::ActiveRecordSource}.
         # @param model [Class<ActiveRecord::Base>]
         # @param find_by_value [Object] Usually an `id`, might be another value if `find_by:` is also provided
@@ -39,6 +56,16 @@ module GraphQL
           source.load(find_by_value)
         end
 
+        # @see dataload_record Like `dataload_record`, but accepts an Array of `find_by_values`
+        def dataload_all_records(model, find_by_values, find_by: nil)
+          source = if find_by
+            dataloader.with(Dataloader::ActiveRecordSource, model, find_by: find_by)
+          else
+            dataloader.with(Dataloader::ActiveRecordSource, model)
+          end
+          source.load_all(find_by_values)
+        end
+
         # Look up an associated record using a Rails association (via {Dataloader::ActiveRecordAssociationSource})
         # @param association_name [Symbol] A `belongs_to` or `has_one` association. (If a `has_many` association is named here, it will be selected without pagination.)
         # @param record [ActiveRecord::Base] The object that the association belongs to.
@@ -56,6 +83,16 @@ module GraphQL
           end
           source.load(record)
         end
+
+        # @see dataload_association Like `dataload_assocation` but accepts an Array of records (required param)
+        def dataload_all_associations(records, association_name, scope: nil)
+          source = if scope
+            dataloader.with(Dataloader::ActiveRecordAssociationSource, association_name, scope)
+          else
+            dataloader.with(Dataloader::ActiveRecordAssociationSource, association_name)
+          end
+          source.load_all(records)
+        end
       end
     end
   end

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

@@ -5,11 +5,88 @@ module GraphQL
     class Member
       # Shared code for Objects, Interfaces, Mutations, Subscriptions
       module HasFields
+        include EmptyObjects
         # Add a field to this object or interface with the given definition
-        # @see {GraphQL::Schema::Field#initialize} for method signature
+        # @param name_positional [Symbol] The underscore-cased version of this field name (will be camelized for the GraphQL API); `name:` keyword is also accepted
+        # @param type_positional [Class, GraphQL::BaseType, Array] The return type of this field; `type:` keyword is also accepted
+        # @param desc_positional [String] Field description; `description:` keyword is also accepted
+        # @option kwargs [Symbol] :name The underscore-cased version of this field name (will be camelized for the GraphQL API); positional argument also accepted
+        # @option kwargs [Class, GraphQL::BaseType, Array] :type The return type of this field; positional argument is also accepted
+        # @option kwargs [Boolean] :null (defaults to `true`) `true` if this field may return `null`, `false` if it is never `null`
+        # @option kwargs [String] :description Field description; positional argument also accepted
+        # @option kwargs [String] :comment Field comment
+        # @option kwargs [String] :deprecation_reason If present, the field is marked "deprecated" with this message
+        # @option kwargs [Symbol] :method The method to call on the underlying object to resolve this field (defaults to `name`)
+        # @option kwargs [String, Symbol] :hash_key The hash key to lookup on the underlying object (if its a Hash) to resolve this field (defaults to `name` or `name.to_s`)
+        # @option kwargs [Array<String, Symbol>] :dig The nested hash keys to lookup on the underlying hash to resolve this field using dig
+        # @option kwargs [Symbol, true] :resolver_method The method on the type to call to resolve this field (defaults to `name`)
+        # @option kwargs [Symbol, true] :resolve_static Used by {Schema.execute_next} to produce a single value, shared by all objects which resolve this field. Called on the owner type class with `context, **arguments`
+        # @option kwargs [Symbol, true] :resolve_batch Used by {Schema.execute_next} map `objects` to a same-sized Array of results. Called on the owner type class with `objects, context, **arguments`.
+        # @option kwargs [Symbol, true] :resolve_each Used by {Schema.execute_next} to get a value value for each item. Called on the owner type class with `object, context, **arguments`.
+        # @option kwargs [Symbol, true] :resolve_legacy_instance_method Used by {Schema.execute_next} to get a value value for each item. Calls an instance method on the object type class.
+        # @option kwargs [Boolean] :connection `true` if this field should get automagic connection behavior; default is to infer by `*Connection` in the return type name
+        # @option kwargs [Class] :connection_extension The extension to add, to implement connections. If `nil`, no extension is added.
+        # @option kwargs [Integer, nil] :max_page_size For connections, the maximum number of items to return from this field, or `nil` to allow unlimited results.
+        # @option kwargs [Integer, nil] :default_page_size For connections, the default number of items to return from this field, or `nil` to return unlimited results.
+        # @option kwargs [Boolean] :introspection If true, this field will be marked as `#introspection?` and the name may begin with `__`
+        # @option kwargs [{String=>GraphQL::Schema::Argument, Hash}] :arguments Arguments for this field (may be added in the block, also)
+        # @option kwargs [Boolean] :camelize If true, the field name will be camelized when building the schema
+        # @option kwargs [Numeric] :complexity When provided, set the complexity for this field
+        # @option kwargs [Boolean] :scope If true, the return type's `.scope_items` method will be called on the return value
+        # @option kwargs [Symbol, String] :subscription_scope A key in `context` which will be used to scope subscription payloads
+        # @option kwargs [Array<Class, Hash<Class => Object>>] :extensions Named extensions to apply to this field (see also {#extension})
+        # @option kwargs [Hash{Class => Hash}] :directives Directives to apply to this field
+        # @option kwargs [Boolean] :trace If true, a {GraphQL::Tracing} tracer will measure this scalar field
+        # @option kwargs [Boolean] :broadcastable Whether or not this field can be distributed in subscription broadcasts
+        # @option kwargs [Language::Nodes::FieldDefinition, nil] :ast_node If this schema was parsed from definition, this AST node defined the field
+        # @option kwargs [Boolean] :method_conflict_warning If false, skip the warning if this field's method conflicts with a built-in method
+        # @option kwargs [Array<Hash>] :validates Configurations for validating this field
+        # @option kwargs [Object] :fallback_value A fallback value if the method is not defined
+        # @option kwargs [Class<GraphQL::Schema::Mutation>] :mutation
+        # @option kwargs [Class<GraphQL::Schema::Resolver>] :resolver
+        # @option kwargs [Class<GraphQL::Schema::Subscription>] :subscription
+        # @option kwargs [Boolean] :dynamic_introspection (Private, used by GraphQL-Ruby)
+        # @option kwargs [Boolean] :relay_node_field (Private, used by GraphQL-Ruby)
+        # @option kwargs [Boolean] :relay_nodes_field (Private, used by GraphQL-Ruby)
+        # @option kwargs [Class, Hash] :dataload Shorthand for dataloader lookups
+        # @option kwargs [Array<:ast_node, :parent, :lookahead, :owner, :execution_errors, :graphql_name, :argument_details, Symbol>] :extras Extra arguments to be injected into the resolver for this field
+        # @param kwargs [Hash] Keywords for defining the field. Any not documented here will be passed to your base field class where they must be handled.
+        # @param definition_block [Proc] an additional block for configuring the field. Receive the field as a block param, or, if no block params are defined, then the block is `instance_eval`'d on the new {Field}.
+        # @yieldparam field [GraphQL::Schema::Field] The newly-created field instance
+        # @yieldreturn [void]
         # @return [GraphQL::Schema::Field]
-        def field(*args, **kwargs, &block)
-          field_defn = field_class.from_options(*args, owner: self, **kwargs, &block)
+        def field(name_positional = nil, type_positional = nil, desc_positional = nil, **kwargs, &definition_block)
+          resolver = kwargs.delete(:resolver)
+          mutation = kwargs.delete(:mutation)
+          subscription = kwargs.delete(:subscription)
+          if (resolver_class = resolver || mutation || subscription)
+            # Add a reference to that parent class
+            kwargs[:resolver_class] = resolver_class
+          end
+
+          kwargs[:name] ||= name_positional
+          if !type_positional.nil?
+            if desc_positional
+              if kwargs[:description]
+                raise ArgumentError, "Provide description as a positional argument or `description:` keyword, but not both (#{desc_positional.inspect}, #{kwargs[:description].inspect})"
+              end
+
+              kwargs[:description] = desc_positional
+              kwargs[:type] = type_positional
+            elsif (resolver || mutation) && type_positional.is_a?(String)
+              # The return type should be copied from the resolver, and the second positional argument is the description
+              kwargs[:description] = type_positional
+            else
+              kwargs[:type] = type_positional
+            end
+
+            if type_positional.is_a?(Class) && type_positional < GraphQL::Schema::Mutation
+              raise ArgumentError, "Use `field #{name_positional.inspect}, mutation: Mutation, ...` to provide a mutation to this field instead"
+            end
+          end
+
+          kwargs[:owner] = self
+          field_defn = field_class.new(**kwargs, &definition_block)
           add_field(field_defn)
           field_defn
         end
@@ -73,10 +150,14 @@ module GraphQL
 
         def global_id_field(field_name, **kwargs)
           type = self
-          field field_name, "ID", **kwargs, null: false
+          field field_name, "ID", **kwargs, null: false, resolve_each: true
           define_method(field_name) do
             context.schema.id_from_object(object, type, context)
           end
+
+          define_singleton_method(field_name) do |object, context|
+            context.schema.id_from_object(object, type, context)
+          end
         end
 
         # @param new_has_no_fields [Boolean] Call with `true` to make this Object type ignore the requirement to have any defined fields.
@@ -232,7 +313,7 @@ module GraphQL
           end
         end
 
-        # @param [GraphQL::Schema::Field]
+        # @param field_defn [GraphQL::Schema::Field]
         # @return [String] A warning to give when this field definition might conflict with a built-in method
         def conflict_field_name_warning(field_defn)
           "#{self.graphql_name}'s `field :#{field_defn.original_name}` conflicts with a built-in method, use `resolver_method:` to pick a different resolver method for this field (for example, `resolver_method: :resolve_#{field_defn.resolver_method}` and `def resolve_#{field_defn.resolver_method}`). Or use `method_conflict_warning: false` to suppress this warning."

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

@@ -8,8 +8,8 @@ module GraphQL
           new_memberships = []
           new_interfaces.each do |int|
             if int.is_a?(Module)
-              unless int.include?(GraphQL::Schema::Interface)
-                raise "#{int} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
+              unless int.include?(GraphQL::Schema::Interface) && !int.is_a?(Class)
+                raise "#{int.respond_to?(:graphql_name) ? "#{int.graphql_name} (#{int})" : int.inspect} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
               end
 
               new_memberships << int.type_membership_class.new(int, self, **options)

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

@@ -12,12 +12,26 @@ module GraphQL
 
         # @return [Schema::NonNull] Make a non-null-type representation of this type
         def to_non_null_type
-          @to_non_null_type ||= GraphQL::Schema::NonNull.new(self)
+          @to_non_null_type || begin
+            t = GraphQL::Schema::NonNull.new(self)
+            if frozen?
+              t
+            else
+              @to_non_null_type = t
+            end
+          end
         end
 
         # @return [Schema::List] Make a list-type representation of this type
         def to_list_type
-          @to_list_type ||= GraphQL::Schema::List.new(self)
+          @to_list_type || begin
+            t = GraphQL::Schema::List.new(self)
+            if frozen?
+              t
+            else
+              @to_list_type = t
+            end
+          end
         end
 
         # @return [Boolean] true if this is a non-nullable type. A nullable list of non-nullables is considered nullable.

data/lib/graphql/schema/member.rb

@@ -2,6 +2,7 @@
 require 'graphql/schema/member/base_dsl_methods'
 require 'graphql/schema/member/graphql_type_names'
 require 'graphql/schema/member/has_ast_node'
+require 'graphql/schema/member/has_authorization'
 require 'graphql/schema/member/has_dataloader'
 require 'graphql/schema/member/has_directives'
 require 'graphql/schema/member/has_deprecation_reason'
@@ -31,6 +32,10 @@ module GraphQL
       extend HasPath
       extend HasAstNode
       extend HasDirectives
+
+      def self.authorizes?(_ctx)
+        false
+      end
     end
   end
 end

data/lib/graphql/schema/non_null.rb

@@ -24,7 +24,7 @@ module GraphQL
       end
 
       def to_type_signature
-        "#{@of_type.to_type_signature}!"
+        @type_signature ||= -"#{@of_type.to_type_signature}!"
       end
 
       def inspect

data/lib/graphql/schema/object.rb

@@ -5,6 +5,7 @@ require "graphql/query/null_context"
 module GraphQL
   class Schema
     class Object < GraphQL::Schema::Member
+      extend GraphQL::Schema::Member::HasAuthorization
       extend GraphQL::Schema::Member::HasFields
       extend GraphQL::Schema::Member::HasInterfaces
       include Member::HasDataloader

data/lib/graphql/schema/ractor_shareable.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    module RactorShareable
+      def self.extended(schema_class)
+        schema_class.extend(SchemaExtension)
+        schema_class.freeze_schema
+      end
+
+      module SchemaExtension
+
+        def freeze_error_handlers(handlers)
+          handlers[:subclass_handlers].default_proc = nil
+          handlers[:subclass_handlers].each do |_class, subclass_handlers|
+            freeze_error_handlers(subclass_handlers)
+          end
+          Ractor.make_shareable(handlers)
+        end
+
+        def freeze_schema
+          # warm some ivars:
+          default_analysis_engine
+          default_execution_strategy
+          GraphQL.default_parser
+          default_logger
+          freeze_error_handlers(error_handlers)
+          # TODO: this freezes errors of parent classes which could cause trouble
+          parent_class = superclass
+          while parent_class.respond_to?(:error_handlers)
+            freeze_error_handlers(parent_class.error_handlers)
+            parent_class = parent_class.superclass
+          end
+
+          own_tracers.freeze
+          @frozen_tracers = tracers.freeze
+          own_trace_modes.each do |m|
+            trace_options_for(m)
+            build_trace_mode(m)
+          end
+          build_trace_mode(:default)
+          Ractor.make_shareable(@trace_options_for_mode)
+          Ractor.make_shareable(own_trace_modes)
+          Ractor.make_shareable(own_multiplex_analyzers)
+          @frozen_multiplex_analyzers = Ractor.make_shareable(multiplex_analyzers)
+          Ractor.make_shareable(own_query_analyzers)
+          @frozen_query_analyzers = Ractor.make_shareable(query_analyzers)
+          Ractor.make_shareable(own_plugins)
+          own_plugins.each do |(plugin, options)|
+            Ractor.make_shareable(plugin)
+            Ractor.make_shareable(options)
+          end
+          @frozen_plugins = Ractor.make_shareable(plugins)
+          Ractor.make_shareable(own_references_to)
+          @frozen_directives = Ractor.make_shareable(directives)
+
+          Ractor.make_shareable(visibility)
+          Ractor.make_shareable(introspection_system)
+          extend(FrozenMethods)
+
+          Ractor.make_shareable(self)
+          superclass.respond_to?(:freeze_schema) && superclass.freeze_schema
+        end
+
+        module FrozenMethods
+          def tracers; @frozen_tracers; end
+          def multiplex_analyzers; @frozen_multiplex_analyzers; end
+          def query_analyzers; @frozen_query_analyzers; end
+          def plugins; @frozen_plugins; end
+          def directives; @frozen_directives; end
+
+          # This actually accumulates info during execution...
+          # How to support it?
+          def lazy?(_obj); false; end
+          def sync_lazy(obj); obj; end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/resolver.rb

@@ -23,6 +23,7 @@ module GraphQL
       # Really we only need description & comment from here, but:
       extend Schema::Member::BaseDSLMethods
       extend GraphQL::Schema::Member::HasArguments
+      extend GraphQL::Schema::Member::HasAuthorization
       extend GraphQL::Schema::Member::HasValidators
       include Schema::Member::HasPath
       extend Schema::Member::HasPath
@@ -45,8 +46,10 @@ module GraphQL
         @prepared_arguments = nil
       end
 
+      attr_accessor :exec_result, :exec_index, :field_resolve_step, :raw_arguments
+
       # @return [Object] The application object this field is being resolved on
-      attr_reader :object
+      attr_accessor :object
 
       # @return [GraphQL::Query::Context]
       attr_reader :context
@@ -54,6 +57,58 @@ module GraphQL
       # @return [GraphQL::Schema::Field]
       attr_reader :field
 
+      attr_writer :prepared_arguments
+
+      def call
+        if self.class < Schema::HasSingleInputArgument
+          @prepared_arguments = @prepared_arguments[:input]
+        end
+        q = context.query
+        trace_objs = [object]
+        q.current_trace.begin_execute_field(field, @prepared_arguments, trace_objs, q)
+        begin
+          is_authed, new_return_value = authorized?(**@prepared_arguments)
+        rescue GraphQL::UnauthorizedError  => err
+          new_return_value = q.schema.unauthorized_object(err)
+          is_authed = true # the error was handled
+        end
+
+        if (runner = @field_resolve_step.runner).resolves_lazies && runner.schema.lazy?(is_authed)
+          is_authed, new_return_value = runner.schema.sync_lazy(is_authed)
+        end
+
+        result = if is_authed
+          Schema::Validator.validate!(self.class.validators, object, context, @prepared_arguments, as: @field)
+          if q.subscription? && @field.owner == context.schema.subscription
+            # This needs to use arguments without `loads:`. TODO extract this into subscription-related code somehow?
+            @original_arguments = @field_resolve_step.runner.input_values[q].argument_values(@field, @field_resolve_step.ast_node.arguments, nil)
+          end
+          call_resolve(@prepared_arguments)
+        elsif new_return_value.nil?
+          err = UnauthorizedFieldError.new(object: object, type: @field_resolve_step.parent_type, context: context, field: @field)
+          context.schema.unauthorized_field(err)
+        else
+          new_return_value
+        end
+        q = context.query
+        q.current_trace.end_execute_field(field, @prepared_arguments, trace_objs, q, [result])
+        exec_result[exec_index] = result
+      rescue RuntimeError => err
+        exec_result[exec_index] = err
+      rescue StandardError => stderr
+        exec_result[exec_index] = begin
+          context.query.handle_or_reraise(stderr)
+        rescue GraphQL::ExecutionError => ex_err
+          ex_err
+        end
+      ensure
+        field_pending_steps = field_resolve_step.pending_steps
+        field_pending_steps.delete(self)
+        if field_pending_steps.size == 0 && field_resolve_step.field_results
+          field_resolve_step.runner.add_step(field_resolve_step)
+        end
+      end
+
       def arguments
         @prepared_arguments || raise("Arguments have not been prepared yet, still waiting for #load_arguments to resolve. (Call `.arguments` later in the code.)")
       end
@@ -154,6 +209,10 @@ module GraphQL
         authorize_arguments(args, inputs)
       end
 
+      def self.authorizes?(context)
+        self.instance_method(:authorized?).owner != GraphQL::Schema::Resolver
+      end
+
       # Called when an object loaded by `loads:` fails the `.authorized?` check for its resolved GraphQL object type.
       #
       # By default, the error is re-raised and passed along to {{Schema.unauthorized_object}}.

data/lib/graphql/schema/subscription.rb

@@ -15,8 +15,6 @@ module GraphQL
       extend GraphQL::Schema::Resolver::HasPayloadType
       extend GraphQL::Schema::Member::HasFields
       NO_UPDATE = :no_update
-      # The generated payload type is required; If there's no payload,
-      # propagate null.
       null false
 
       # @api private