graphql 2.5.18 → 2.5.20

data/lib/graphql/introspection/input_value_type.rb

@@ -9,53 +9,61 @@ module GraphQL
       field :name, String, null: false
       field :description, String
       field :type, GraphQL::Schema::LateBoundType.new("__Type"), null: false
-      field :default_value, String, "A GraphQL-formatted string representing the default value for this input value."
-      field :is_deprecated, Boolean, null: false
+      field :default_value, String, "A GraphQL-formatted string representing the default value for this input value.", resolve_each: :resolve_default_value
+      field :is_deprecated, Boolean, null: false, resolve_each: :resolve_is_deprecated
       field :deprecation_reason, String
 
+      def self.resolve_is_deprecated(object, context)
+        !!object.deprecation_reason
+      end
+
       def is_deprecated
-        !!@object.deprecation_reason
+        self.class.resolve_is_deprecated(object, context)
       end
 
-      def default_value
-        if @object.default_value?
-          value = @object.default_value
+      def self.resolve_default_value(object, context)
+        if object.default_value?
+          value = object.default_value
           if value.nil?
             'null'
           else
-            if (@object.type.kind.list? || (@object.type.kind.non_null? && @object.type.of_type.kind.list?)) && !value.respond_to?(:map)
+            if (object.type.kind.list? || (object.type.kind.non_null? && object.type.of_type.kind.list?)) && !value.respond_to?(:map)
               # This is a bit odd -- we expect the default value to be an application-style value, so we use coerce result below.
               # But coerce_result doesn't wrap single-item lists, which are valid inputs to list types.
               # So, apply that wrapper here if needed.
               value = [value]
             end
-            coerced_default_value = @object.type.coerce_result(value, @context)
-            serialize_default_value(coerced_default_value, @object.type)
+            coerced_default_value = object.type.coerce_result(value, context)
+            serialize_default_value(coerced_default_value, object.type, context)
           end
         else
           nil
         end
       end
 
+      def default_value
+        self.class.resolve_default_value(object, context)
+      end
+
 
       private
 
       # Recursively serialize, taking care not to add quotes to enum values
-      def serialize_default_value(value, type)
+      def self.serialize_default_value(value, type, context)
         if value.nil?
           'null'
         elsif type.kind.list?
           inner_type = type.of_type
-          "[" + value.map { |v| serialize_default_value(v, inner_type) }.join(", ") + "]"
+          "[" + value.map { |v| serialize_default_value(v, inner_type, context) }.join(", ") + "]"
         elsif type.kind.non_null?
-          serialize_default_value(value, type.of_type)
+          serialize_default_value(value, type.of_type, context)
         elsif type.kind.enum?
           value
         elsif type.kind.input_object?
           "{" +
             value.map do |k, v|
               arg_defn = type.get_argument(k, context)
-              "#{k}: #{serialize_default_value(v, arg_defn.type)}"
+              "#{k}: #{serialize_default_value(v, arg_defn.type, context)}"
             end.join(", ") +
             "}"
         else

data/lib/graphql/introspection/type_type.rb

@@ -11,32 +11,36 @@ module GraphQL
                   "they describe. Abstract types, Union and Interface, provide the Object types "\
                   "possible at runtime. List and NonNull types compose other types."
 
-      field :kind, GraphQL::Schema::LateBoundType.new("__TypeKind"), null: false
+      field :kind, GraphQL::Schema::LateBoundType.new("__TypeKind"), null: false, resolve_each: :resolve_kind
       field :name, String, method: :graphql_name
       field :description, String
-      field :fields, [GraphQL::Schema::LateBoundType.new("__Field")], scope: false do
+      field :fields, [GraphQL::Schema::LateBoundType.new("__Field")], scope: false, resolve_each: :resolve_fields do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
-      field :interfaces, [GraphQL::Schema::LateBoundType.new("__Type")], scope: false
-      field :possible_types, [GraphQL::Schema::LateBoundType.new("__Type")], scope: false
-      field :enum_values, [GraphQL::Schema::LateBoundType.new("__EnumValue")], scope: false do
+      field :interfaces, [GraphQL::Schema::LateBoundType.new("__Type")], scope: false, resolve_each: :resolve_interfaces
+      field :possible_types, [GraphQL::Schema::LateBoundType.new("__Type")], scope: false, resolve_each: :resolve_possible_types
+      field :enum_values, [GraphQL::Schema::LateBoundType.new("__EnumValue")], scope: false, resolve_each: :resolve_enum_values do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
-      field :input_fields, [GraphQL::Schema::LateBoundType.new("__InputValue")], scope: false  do
+      field :input_fields, [GraphQL::Schema::LateBoundType.new("__InputValue")], scope: false, resolve_each: :resolve_input_fields  do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
-      field :of_type, GraphQL::Schema::LateBoundType.new("__Type")
+      field :of_type, GraphQL::Schema::LateBoundType.new("__Type"), resolve_each: :resolve_of_type
 
-      field :specifiedByURL, String, resolver_method: :specified_by_url
+      field :specifiedByURL, String, resolve_each: :resolve_specified_by_url, resolver_method: :specified_by_url
 
-      field :is_one_of, Boolean, null: false
+      field :is_one_of, Boolean, null: false, resolve_each: :resolve_is_one_of
 
-      def is_one_of
+      def self.resolve_is_one_of(object, _ctx)
         object.kind.input_object? &&
           object.directives.any? { |d| d.graphql_name == "oneOf" }
       end
 
-      def specified_by_url
+      def is_one_of
+        self.class.resolve_is_one_of(object, context)
+      end
+
+      def self.resolve_specified_by_url(object, _ctx)
         if object.kind.scalar?
           object.specified_by_url
         else
@@ -44,15 +48,23 @@ module GraphQL
         end
       end
 
+      def specified_by_url
+        self.class.resolve_specified_by_url(object, context)
+      end
+
+      def self.resolve_kind(object, context)
+        object.kind.name
+      end
+
       def kind
-        @object.kind.name
+        self.class.resolve_kind(object, context)
       end
 
-      def enum_values(include_deprecated:)
-        if !@object.kind.enum?
+      def self.resolve_enum_values(object, context, include_deprecated:)
+        if !object.kind.enum?
           nil
         else
-          enum_values = @context.types.enum_values(@object)
+          enum_values = context.types.enum_values(object)
 
           if !include_deprecated
             enum_values = enum_values.select {|f| !f.deprecation_reason }
@@ -62,17 +74,25 @@ module GraphQL
         end
       end
 
-      def interfaces
-        if @object.kind.object? || @object.kind.interface?
-          @context.types.interfaces(@object).sort_by(&:graphql_name)
+      def enum_values(include_deprecated:)
+        self.class.resolve_enum_values(object, context, include_deprecated: include_deprecated)
+      end
+
+      def self.resolve_interfaces(object, context)
+        if object.kind.object? || object.kind.interface?
+          context.types.interfaces(object).sort_by(&:graphql_name)
         else
           nil
         end
       end
 
-      def input_fields(include_deprecated:)
-        if @object.kind.input_object?
-          args = @context.types.arguments(@object)
+      def interfaces
+        self.class.resolve_interfaces(object, context)
+      end
+
+      def self.resolve_input_fields(object, context, include_deprecated:)
+        if object.kind.input_object?
+          args = context.types.arguments(object)
           args = args.reject(&:deprecation_reason) unless include_deprecated
           args
         else
@@ -80,19 +100,27 @@ module GraphQL
         end
       end
 
-      def possible_types
-        if @object.kind.abstract?
-          @context.types.possible_types(@object).sort_by(&:graphql_name)
+      def input_fields(include_deprecated:)
+        self.class.resolve_input_fields(object, context, include_deprecated: include_deprecated)
+      end
+
+      def self.resolve_possible_types(object, context)
+        if object.kind.abstract?
+          context.types.possible_types(object).sort_by(&:graphql_name)
         else
           nil
         end
       end
 
-      def fields(include_deprecated:)
-        if !@object.kind.fields?
+      def possible_types
+        self.class.resolve_possible_types(object, context)
+      end
+
+      def self.resolve_fields(object, context, include_deprecated:)
+        if !object.kind.fields?
           nil
         else
-          fields = @context.types.fields(@object)
+          fields = context.types.fields(object)
           if !include_deprecated
             fields = fields.select {|f| !f.deprecation_reason }
           end
@@ -100,8 +128,16 @@ module GraphQL
         end
       end
 
+      def fields(include_deprecated:)
+        self.class.resolve_fields(object, context, include_deprecated: include_deprecated)
+      end
+
+      def self.resolve_of_type(object, _ctx)
+        object.kind.wraps? ? object.of_type : nil
+      end
+
       def of_type
-        @object.kind.wraps? ? @object.of_type : nil
+        self.class.resolve_of_type(object, context)
       end
     end
   end

data/lib/graphql/invalid_null_error.rb

@@ -2,7 +2,7 @@
 module GraphQL
   # Raised automatically when a field's resolve function returns `nil`
   # for a non-null field.
-  class InvalidNullError < GraphQL::Error
+  class InvalidNullError < GraphQL::RuntimeError
     # @return [GraphQL::BaseType] The owner of {#field}
     attr_reader :parent_type
 
@@ -10,17 +10,23 @@ module GraphQL
     attr_reader :field
 
     # @return [GraphQL::Language::Nodes::Field] the field where the error occurred
-    attr_reader :ast_node
+    def ast_node
+      @ast_nodes.first
+    end
+
+    attr_reader :ast_nodes
 
     # @return [Boolean] indicates an array result caused the error
     attr_reader :is_from_array
 
-    def initialize(parent_type, field, ast_node, is_from_array: false)
+    attr_accessor :path
+
+    def initialize(parent_type, field, ast_node_or_nodes, is_from_array: false, path: nil)
       @parent_type = parent_type
       @field = field
-      @ast_node = ast_node
+      @ast_nodes = Array(ast_node_or_nodes)
       @is_from_array = is_from_array
-
+      @path = path
       # For List elements, identify the non-null error is for an
       # element and the required element type so it's not ambiguous
       # whether it was caused by a null instead of the list or a

data/lib/graphql/query/context.rb

@@ -29,6 +29,7 @@ module GraphQL
       end
 
       extend Forwardable
+      include Schema::Member::HasDataloader
 
       # @return [Array<GraphQL::ExecutionError>] errors returned during execution
       attr_reader :errors
@@ -118,8 +119,8 @@ module GraphQL
       # @param error [GraphQL::ExecutionError] an execution error
       # @return [void]
       def add_error(error)
-        if !error.is_a?(ExecutionError)
-          raise TypeError, "expected error to be a ExecutionError, but was #{error.class}"
+        if !error.is_a?(GraphQL::RuntimeError)
+          raise TypeError, "expected error to be a GraphQL::RuntimeError, but was #{error.class}"
         end
         errors << error
         nil

data/lib/graphql/query/null_context.rb

@@ -4,7 +4,13 @@ module GraphQL
   class Query
     # This object can be `ctx` in places where there is no query
     class NullContext < Context
-      include Singleton
+      def self.instance
+        @instance ||= self.new
+      end
+
+      def self.instance=(new_inst)
+        @instance = new_inst
+      end
 
       class NullQuery
         def after_lazy(value)
@@ -20,10 +26,10 @@ module GraphQL
       attr_reader :schema, :query, :warden, :dataloader
       def_delegators GraphQL::EmptyObjects::EMPTY_HASH, :[], :fetch, :dig, :key?, :to_h
 
-      def initialize
+      def initialize(schema: NullSchema)
         @query = NullQuery.new
         @dataloader = GraphQL::Dataloader::NullDataloader.new
-        @schema = NullSchema
+        @schema = schema
         @warden = Schema::Warden::NullWarden.new(context: self, schema: @schema)
         @types = @warden.visibility_profile
         freeze

data/lib/graphql/schema/argument.rb

@@ -164,6 +164,10 @@ module GraphQL
         true
       end
 
+      def authorizes?(_context)
+        self.method(:authorized?).owner != GraphQL::Schema::Argument
+      end
+
       def authorized?(obj, value, ctx)
         authorized_as_type?(obj, value, ctx, as_type: type)
       end

data/lib/graphql/schema/build_from_definition.rb

@@ -512,22 +512,42 @@ module GraphQL
               camelize: false,
               directives: prepare_directives(field_definition, type_resolver),
               resolver_method: resolve_method_name,
+              resolve_batch: resolve_method_name,
             )
 
             builder.build_arguments(schema_field_defn, field_definition.arguments, type_resolver)
 
             # Don't do this for interfaces
             if default_resolve
-              define_field_resolve_method(owner, resolve_method_name, field_definition.name)
+              define_field_resolve_method(owner, resolve_method_name, field_definition.name, field_definition.arguments.empty?)
             end
           end
         end
 
-        def define_field_resolve_method(owner, method_name, field_name)
-          owner.define_method(method_name) { |**args|
-            field_instance = context.types.field(owner, field_name)
-            context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
-          }
+        def define_field_resolve_method(owner, method_name, field_name, empty_arguments)
+          if empty_arguments
+            owner.define_method(method_name) {
+              field_instance = context.types.field(owner, field_name)
+              context.schema.definition_default_resolve.call(self.class, field_instance, object, EmptyObjects::EMPTY_HASH, context)
+            }
+            owner.define_singleton_method(method_name) { |objects, context|
+              field_instance = context.types.field(owner, field_name)
+              objects.map do |object|
+                context.schema.definition_default_resolve.call(self, field_instance, object, EmptyObjects::EMPTY_HASH, context)
+              end
+            }
+          else
+            owner.define_method(method_name) { |**args|
+              field_instance = context.types.field(owner, field_name)
+              context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
+            }
+            owner.define_singleton_method(method_name) { |objects, context, **args|
+              field_instance = context.types.field(owner, field_name)
+              objects.map do |object|
+                context.schema.definition_default_resolve.call(self, field_instance, object, args, context)
+              end
+            }
+          end
         end
 
         def build_resolve_type(lookup_hash, directives, missing_type_handler)

data/lib/graphql/schema/field.rb

@@ -192,6 +192,9 @@ module GraphQL
       # @param resolver_method [Symbol] The method on the type to call to resolve this field (defaults to `name`)
       # @param connection [Boolean] `true` if this field should get automagic connection behavior; default is to infer by `*Connection` in the return type name
       # @param connection_extension [Class] The extension to add, to implement connections. If `nil`, no extension is added.
+      # @param resolve_static [Symbol, nil] Used by {Schema.execute_batching} to produce a single value, shared by all objects which resolve this field. Called on the owner type class with `context, **arguments`
+      # @param resolve_batch [Symbol, nil] Used by {Schema.execute_batching} map `objects` to a same-sized Array of results. Called on the owner type class with `objects, context, **arguments`.
+      # @param resolve_each [Symbol, nil] Used by {Schema.execute_batching} to get a value value for each item. Called on the owner type class with `object, context, **arguments`.
       # @param max_page_size [Integer, nil] For connections, the maximum number of items to return from this field, or `nil` to allow unlimited results.
       # @param default_page_size [Integer, nil] For connections, the default number of items to return from this field, or `nil` to return unlimited results.
       # @param introspection [Boolean] If true, this field will be marked as `#introspection?` and the name may begin with `__`
@@ -214,7 +217,7 @@ module GraphQL
       # @param relay_nodes_field [Boolean] (Private, used by GraphQL-Ruby)
       # @param extras [Array<:ast_node, :parent, :lookahead, :owner, :execution_errors, :graphql_name, :argument_details, Symbol>] Extra arguments to be injected into the resolver for this field
       # @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}.
-      def initialize(type: nil, name: nil, owner: nil, null: nil, description: NOT_CONFIGURED, comment: NOT_CONFIGURED, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: NOT_CONFIGURED, default_page_size: NOT_CONFIGURED, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, 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: NOT_CONFIGURED, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: NOT_CONFIGURED, dynamic_introspection: false, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: nil, description: NOT_CONFIGURED, comment: NOT_CONFIGURED, deprecation_reason: nil, method: nil, resolve_static: nil, resolve_each: nil, resolve_batch: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: NOT_CONFIGURED, default_page_size: NOT_CONFIGURED, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, 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: NOT_CONFIGURED, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: NOT_CONFIGURED, dynamic_introspection: false, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -262,6 +265,27 @@ module GraphQL
         @method_str = -method_name.to_s
         @method_sym = method_name.to_sym
         @resolver_method = (resolver_method || name_s).to_sym
+
+        if resolve_static
+          @batch_mode = :resolve_static
+          @batch_mode_key = resolve_static == true ? @method_sym : resolve_static
+        elsif resolve_batch
+          @batch_mode = :resolve_batch
+          @batch_mode_key = resolve_batch == true ? @method_sym : resolve_batch
+        elsif resolve_each
+          @batch_mode = :resolve_each
+          @batch_mode_key = resolve_each == true ? @method_sym : resolve_each
+        elsif hash_key
+          @batch_mode = :hash_key
+          @batch_mode_key = hash_key
+        elsif dig
+          @batch_mode = :dig
+          @batch_mode_key = dig
+        else
+          @batch_mode = :direct_send
+          @batch_mode_key = @method_sym
+        end
+
         @complexity = complexity
         @dynamic_introspection = dynamic_introspection
         @return_type_expr = type
@@ -332,6 +356,50 @@ module GraphQL
         end
       end
 
+      # Called by {Execution::Batching} to resolve this field for each of `objects`
+      # @param field_resolve_step [Execution::Batching::FieldResolveStep] an internal metadata object from execution code
+      # @param objects [Array<Object>] Objects returned from previously-executed fields
+      # @param context [GraphQL::Query::Context]
+      # @param args_hash [Hash<Symbol => Object>] Ruby-style arguments for this field
+      # @return [Array<Object>] One field result for each of `objects`; must have the same length as `objects`
+      # @see #initialize Use `resolve_static:`, `resolve_batch:`, `resolve_each:`, `hash_key:`, or `method:`
+      # @api private
+      def resolve_batch(field_resolve_step, objects, context, args_hash)
+        case @batch_mode
+        when :resolve_batch
+          if args_hash.empty?
+            @owner.public_send(@batch_mode_key, objects, context)
+          else
+            @owner.public_send(@batch_mode_key, objects, context, **args_hash)
+          end
+        when :resolve_static
+          result = if args_hash.empty?
+            @owner.public_send(@batch_mode_key, context)
+          else
+            @owner.public_send(@batch_mode_key, context, **args_hash)
+          end
+          Array.new(objects.size, result)
+        when :resolve_each
+          if args_hash.empty?
+            objects.map { |o| @owner.public_send(@batch_mode_key, o, context) }
+          else
+            objects.map { |o| @owner.public_send(@batch_mode_key, o, context, **args_hash) }
+          end
+        when :hash_key
+          objects.map { |o| o[@batch_mode_key] }
+        when :direct_send
+          if args_hash.empty?
+            objects.map { |o| o.public_send(@batch_mode_key) }
+          else
+            objects.map { |o| o.public_send(@batch_mode_key, **args_hash) }
+          end
+        when :dig
+          objects.map { |o| o.dig(*@batch_mode_key) }
+        else
+          raise "Batching execution for #{path} not implemented; provide `resolve_static:`, `resolve_batch:`, `hash_key:`, `method:`, or use a compatibility plug-in"
+        end
+      end
+
       # Calls the definition block, if one was given.
       # This is deferred so that references to the return type
       # can be lazily evaluated, reducing Rails boot time.
@@ -625,6 +693,13 @@ module GraphQL
         end
       end
 
+      def authorizes?(context)
+        method(:authorized?).owner != GraphQL::Schema::Field || (
+          (args = context.types.arguments(self)) &&
+            (args.any? { |a| a.authorizes?(context) })
+        )
+      end
+
       def authorized?(object, args, context)
         if @resolver_class
           # The resolver _instance_ will check itself during `resolve()`

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

@@ -20,6 +20,15 @@ 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)`
+        # @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

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

@@ -20,6 +20,9 @@ module GraphQL
         # @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] :resolver_method The method on the type to call to resolve this field (defaults to `name`)
+        # @option kwargs [Symbol] :resolve_static Used by {Schema.execute_batching} 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] :resolve_batch Used by {Schema.execute_batching} map `objects` to a same-sized Array of results. Called on the owner type class with `objects, context, **arguments`.
+        # @option kwargs [Symbol] :resolve_each Used by {Schema.execute_batching} to get a value value for each item. Called on the owner type class with `object, context, **arguments`.
         # @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.

data/lib/graphql/schema/resolver.rb

@@ -46,7 +46,7 @@ module GraphQL
       end
 
       # @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 +54,8 @@ module GraphQL
       # @return [GraphQL::Schema::Field]
       attr_reader :field
 
+      attr_writer :prepared_arguments
+
       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

data/lib/graphql/schema/visibility.rb

@@ -191,7 +191,7 @@ module GraphQL
         if refresh
           @top_level_profile = nil
         end
-        @top_level_profile ||= @schema.visibility_profile_class.new(context: Query::NullContext.instance, schema: @schema, visibility: self)
+        @top_level_profile ||= @schema.visibility_profile_class.new(context: @schema.null_context, schema: @schema, visibility: self)
       end
 
       private

data/lib/graphql/schema.rb

@@ -330,10 +330,16 @@ module GraphQL
         find_inherited_value(:plugins, EMPTY_ARRAY) + own_plugins
       end
 
+      attr_writer :null_context
+
+      def null_context
+        @null_context || GraphQL::Query::NullContext.instance
+      end
+
       # Build a map of `{ name => type }` and return it
       # @return [Hash<String => Class>] A dictionary of type classes by their GraphQL name
       # @see get_type Which is more efficient for finding _one type_ by name, because it doesn't merge hashes.
-      def types(context = GraphQL::Query::NullContext.instance)
+      def types(context = null_context)
         if use_visibility_profile?
           types = Visibility::Profile.from_context(context, self)
           return types.all_types_h
@@ -366,7 +372,7 @@ module GraphQL
       # @param context [GraphQL::Query::Context] Used for filtering definitions at query-time
       # @param use_visibility_profile Private, for migration to {Schema::Visibility}
       # @return [Module, nil] A type, or nil if there's no type called `type_name`
-      def get_type(type_name, context = GraphQL::Query::NullContext.instance, use_visibility_profile = use_visibility_profile?)
+      def get_type(type_name, context = null_context, use_visibility_profile = use_visibility_profile?)
         if use_visibility_profile
           profile = Visibility::Profile.from_context(context, self)
           return profile.type(type_name)
@@ -617,7 +623,7 @@ module GraphQL
       # @param use_visibility_profile Private, for migration to {Schema::Visibility}
       # @return [Hash<String, Module>] All possible types, if no `type` is given.
       # @return [Array<Module>] Possible types for `type`, if it's given.
-      def possible_types(type = nil, context = GraphQL::Query::NullContext.instance, use_visibility_profile = use_visibility_profile?)
+      def possible_types(type = nil, context = null_context, use_visibility_profile = use_visibility_profile?)
         if use_visibility_profile
           if type
             return Visibility::Profile.from_context(context, self).possible_types(type)
@@ -701,7 +707,7 @@ module GraphQL
         GraphQL::Schema::TypeExpression.build_type(context.query.types, ast_node)
       end
 
-      def get_field(type_or_name, field_name, context = GraphQL::Query::NullContext.instance, use_visibility_profile = use_visibility_profile?)
+      def get_field(type_or_name, field_name, context = null_context, use_visibility_profile = use_visibility_profile?)
         if use_visibility_profile
           profile = Visibility::Profile.from_context(context, self)
           parent_type = case type_or_name
@@ -738,7 +744,7 @@ module GraphQL
         end
       end
 
-      def get_fields(type, context = GraphQL::Query::NullContext.instance)
+      def get_fields(type, context = null_context)
         type.fields(context)
       end
 
@@ -1228,6 +1234,7 @@ module GraphQL
           vis = self.visibility
           child_class.visibility = vis.dup_for(child_class)
         end
+        child_class.null_context = Query::NullContext.new(schema: child_class)
         super
       end
 
@@ -1329,10 +1336,11 @@ module GraphQL
       def type_error(type_error, context)
         case type_error
         when GraphQL::InvalidNullError
-          execution_error = GraphQL::ExecutionError.new(type_error.message, ast_node: type_error.ast_node)
-          execution_error.path = context[:current_path]
+          execution_error = GraphQL::ExecutionError.new(type_error.message, ast_nodes: type_error.ast_nodes)
+          execution_error.path = type_error.path || context[:current_path]
 
           context.errors << execution_error
+          execution_error
         when GraphQL::UnresolvedTypeError, GraphQL::StringEncodingError, GraphQL::IntegerEncodingError
           raise type_error
         when GraphQL::IntegerDecodingError
@@ -1354,6 +1362,24 @@ module GraphQL
         lazy_methods.set(lazy_class, value_method)
       end
 
+      def uses_raw_value?
+        !!@uses_raw_value
+      end
+
+      def uses_raw_value(new_val)
+        @uses_raw_value = new_val
+      end
+
+      def resolves_lazies?
+        lazy_method_count = 0
+        lazy_methods.each do |k, v|
+          if !v.nil?
+            lazy_method_count += 1
+          end
+        end
+        lazy_method_count > 2
+      end
+
       def instrument(instrument_step, instrumenter, options = {})
         warn <<~WARN
         Schema.instrument is deprecated, use `trace_with` instead: https://graphql-ruby.org/queries/tracing.html"

data/lib/graphql/subscriptions.rb

@@ -80,7 +80,7 @@ module GraphQL
 
       # Normalize symbol-keyed args to strings, try camelizing them
       # Should this accept a real context somehow?
-      normalized_args = normalize_arguments(normalized_event_name, field, args, GraphQL::Query::NullContext.instance)
+      normalized_args = normalize_arguments(normalized_event_name, field, args, @schema.null_context)
 
       event = Subscriptions::Event.new(
         name: normalized_event_name,