graphql 1.10.1 → 1.13.0

data/lib/graphql/schema.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "graphql/schema/addition"
 require "graphql/schema/base_64_encoder"
 require "graphql/schema/catchall_middleware"
 require "graphql/schema/default_parse_error"
@@ -21,6 +22,7 @@ require "graphql/schema/validation"
 require "graphql/schema/warden"
 require "graphql/schema/build_from_definition"
 
+require "graphql/schema/validator"
 require "graphql/schema/member"
 require "graphql/schema/wrapper"
 require "graphql/schema/list"
@@ -40,6 +42,7 @@ require "graphql/schema/directive/deprecated"
 require "graphql/schema/directive/include"
 require "graphql/schema/directive/skip"
 require "graphql/schema/directive/feature"
+require "graphql/schema/directive/flagged"
 require "graphql/schema/directive/transform"
 require "graphql/schema/type_membership"
 
@@ -80,8 +83,17 @@ module GraphQL
     extend GraphQL::Schema::Member::AcceptsDefinition
     extend GraphQL::Schema::Member::HasAstNode
     include GraphQL::Define::InstanceDefinable
+    extend GraphQL::Define::InstanceDefinable::DeprecatedDefine
     extend GraphQL::Schema::FindInheritedValue
 
+    class DuplicateTypeNamesError < GraphQL::Error
+      def initialize(type_name:, first_definition:, second_definition:, path:)
+        super("Multiple definitions for `#{type_name}`. Previously found #{first_definition.inspect} (#{first_definition.class}), then found #{second_definition.inspect} (#{second_definition.class}) at #{path.join(".")}")
+      end
+    end
+
+    class DuplicateNamesError < GraphQL::Error; end
+
     class UnresolvedLateBoundTypeError < GraphQL::Error
       attr_reader :type
       def initialize(type:)
@@ -90,9 +102,68 @@ module GraphQL
       end
     end
 
+    module LazyHandlingMethods
+      # Call the given block at the right time, either:
+      # - Right away, if `value` is not registered with `lazy_resolve`
+      # - After resolving `value`, if it's registered with `lazy_resolve` (eg, `Promise`)
+      # @api private
+      def after_lazy(value, &block)
+        if lazy?(value)
+          GraphQL::Execution::Lazy.new do
+            result = sync_lazy(value)
+            # The returned result might also be lazy, so check it, too
+            after_lazy(result, &block)
+          end
+        else
+          yield(value) if block_given?
+        end
+      end
+
+      # Override this method to handle lazy objects in a custom way.
+      # @param value [Object] an instance of a class registered with {.lazy_resolve}
+      # @return [Object] A GraphQL-ready (non-lazy) object
+      # @api private
+      def sync_lazy(value)
+        lazy_method = lazy_method_name(value)
+        if lazy_method
+          synced_value = value.public_send(lazy_method)
+          sync_lazy(synced_value)
+        else
+          value
+        end
+      end
+
+      # @return [Symbol, nil] The method name to lazily resolve `obj`, or nil if `obj`'s class wasn't registered with {#lazy_resolve}.
+      def lazy_method_name(obj)
+        lazy_methods.get(obj)
+      end
+
+      # @return [Boolean] True if this object should be lazily resolved
+      def lazy?(obj)
+        !!lazy_method_name(obj)
+      end
+
+      # Return a lazy if any of `maybe_lazies` are lazy,
+      # otherwise, call the block eagerly and return the result.
+      # @param maybe_lazies [Array]
+      # @api private
+      def after_any_lazies(maybe_lazies)
+        if maybe_lazies.any? { |l| lazy?(l) }
+          GraphQL::Execution::Lazy.all(maybe_lazies).then do |result|
+            yield result
+          end
+        else
+          yield maybe_lazies
+        end
+      end
+    end
+
+    include LazyHandlingMethods
+    extend LazyHandlingMethods
+
     accepts_definitions \
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
-      :max_depth, :max_complexity, :default_max_page_size,
+      :validate_timeout, :validate_max_errors, :max_depth, :max_complexity, :default_max_page_size,
       :orphan_types, :resolve_type, :type_error, :parse_error,
       :error_bubbling,
       :raise_definition_error,
@@ -116,7 +187,7 @@ module GraphQL
       },
       query_analyzer: ->(schema, analyzer) {
         if analyzer == GraphQL::Authorization::Analyzer
-          warn("The Authorization query analyzer is deprecated. Authorizing at query runtime is generally a better idea.")
+          GraphQL::Deprecation.warn("The Authorization query analyzer is deprecated. Authorizing at query runtime is generally a better idea.")
         end
         schema.query_analyzers << analyzer
       },
@@ -131,7 +202,7 @@ module GraphQL
     attr_accessor \
       :query, :mutation, :subscription,
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
-      :max_depth, :max_complexity, :default_max_page_size,
+      :validate_timeout, :validate_max_errors, :max_depth, :max_complexity, :default_max_page_size,
       :orphan_types, :directives,
       :query_analyzers, :multiplex_analyzers, :instrumenters, :lazy_methods,
       :cursor_encoder,
@@ -216,11 +287,11 @@ module GraphQL
       @lazy_methods = GraphQL::Execution::Lazy::LazyMethodMap.new
       @lazy_methods.set(GraphQL::Execution::Lazy, :value)
       @cursor_encoder = Base64Encoder
-      # Default to the built-in execution strategy:
+      # For schema instances, default to legacy runtime modules
       @analysis_engine = GraphQL::Analysis
-      @query_execution_strategy = self.class.default_execution_strategy
-      @mutation_execution_strategy = self.class.default_execution_strategy
-      @subscription_execution_strategy = self.class.default_execution_strategy
+      @query_execution_strategy = GraphQL::Execution::Execute
+      @mutation_execution_strategy = GraphQL::Execution::Execute
+      @subscription_execution_strategy = GraphQL::Execution::Execute
       @default_mask = GraphQL::Schema::NullMask
       @rebuilding_artifacts = false
       @context_class = GraphQL::Query::Context
@@ -235,12 +306,11 @@ module GraphQL
 
     # @return [Boolean] True if using the new {GraphQL::Execution::Interpreter}
     def interpreter?
-      @interpreter
+      query_execution_strategy == GraphQL::Execution::Interpreter &&
+        mutation_execution_strategy == GraphQL::Execution::Interpreter &&
+        subscription_execution_strategy == GraphQL::Execution::Interpreter
     end
 
-    # @api private
-    attr_writer :interpreter
-
     def inspect
       "#<#{self.class.name} ...>"
     end
@@ -288,24 +358,7 @@ module GraphQL
     # For forwards-compatibility with Schema classes
     alias :graphql_definition :itself
 
-    # Validate a query string according to this schema.
-    # @param string_or_document [String, GraphQL::Language::Nodes::Document]
-    # @return [Array<GraphQL::StaticValidation::Error >]
-    def validate(string_or_document, rules: nil, context: nil)
-      doc = if string_or_document.is_a?(String)
-        GraphQL.parse(string_or_document)
-      else
-        string_or_document
-      end
-      query = GraphQL::Query.new(self, document: doc, context: context)
-      validator_opts = { schema: self }
-      rules && (validator_opts[:rules] = rules)
-      validator = GraphQL::StaticValidation::Validator.new(**validator_opts)
-      res = validator.validate(query)
-      res[:errors]
-    end
-
-    def define(**kwargs, &block)
+    def deprecated_define(**kwargs, &block)
       super
       ensure_defined
       # Assert that all necessary configs are present:
@@ -488,11 +541,20 @@ module GraphQL
     # @param context [GraphQL::Query::Context] The context for the current query
     # @return [Array<GraphQL::ObjectType>] types which belong to `type_defn` in this schema
     def possible_types(type_defn, context = GraphQL::Query::NullContext)
-      @possible_types ||= GraphQL::Schema::PossibleTypes.new(self)
-      @possible_types.possible_types(type_defn, context)
+      if context == GraphQL::Query::NullContext
+        @possible_types ||= GraphQL::Schema::PossibleTypes.new(self)
+        @possible_types.possible_types(type_defn, context)
+      else
+        # Use the incoming context to cache this instance --
+        # if it were cached on the schema, we'd have a memory leak
+        # https://github.com/rmosolgo/graphql-ruby/issues/2878
+        ns = context.namespace(:possible_types)
+        per_query_possible_types = ns[:possible_types] ||= GraphQL::Schema::PossibleTypes.new(self)
+        per_query_possible_types.possible_types(type_defn, context)
+      end
     end
 
-    # @see [GraphQL::Schema::Warden] Resticted access to root types
+    # @see [GraphQL::Schema::Warden] Restricted access to root types
     # @return [GraphQL::ObjectType, nil]
     def root_type_for_operation(operation)
       case operation
@@ -636,6 +698,7 @@ module GraphQL
     def_delegators :_schema_class, :unauthorized_object, :unauthorized_field, :inaccessible_fields
     def_delegators :_schema_class, :directive
     def_delegators :_schema_class, :error_handler
+    def_delegators :_schema_class, :validate
 
 
     # Given this schema member, find the class-based definition object
@@ -713,31 +776,29 @@ module GraphQL
     # @param default_resolve [<#call(type, field, obj, args, ctx)>] A callable for handling field resolution
     # @param parser [Object] An object for handling definition string parsing (must respond to `parse`)
     # @param using [Hash] Plugins to attach to the created schema with `use(key, value)`
-    # @param interpreter [Boolean] If false, the legacy {Execution::Execute} runtime will be used
     # @return [Class] the schema described by `document`
-    def self.from_definition(definition_or_path, default_resolve: BuildFromDefinition::DefaultResolve, interpreter: true, parser: BuildFromDefinition::DefaultParser, using: {})
+    def self.from_definition(definition_or_path, default_resolve: nil, parser: GraphQL.default_parser, using: {})
       # If the file ends in `.graphql`, treat it like a filepath
-      definition = if definition_or_path.end_with?(".graphql")
-        File.read(definition_or_path)
+      if definition_or_path.end_with?(".graphql")
+        GraphQL::Schema::BuildFromDefinition.from_definition_path(
+          definition_or_path,
+          default_resolve: default_resolve,
+          parser: parser,
+          using: using,
+        )
       else
-        definition_or_path
+        GraphQL::Schema::BuildFromDefinition.from_definition(
+          definition_or_path,
+          default_resolve: default_resolve,
+          parser: parser,
+          using: using,
+        )
       end
-      GraphQL::Schema::BuildFromDefinition.from_definition(definition, default_resolve: default_resolve, parser: parser, using: using, interpreter: interpreter)
     end
 
     # Error that is raised when [#Schema#from_definition] is passed an invalid schema definition string.
     class InvalidDocumentError < Error; end;
 
-    # @return [Symbol, nil] The method name to lazily resolve `obj`, or nil if `obj`'s class wasn't registered wtih {#lazy_resolve}.
-    def lazy_method_name(obj)
-      @lazy_methods.get(obj)
-    end
-
-    # @return [Boolean] True if this object should be lazily resolved
-    def lazy?(obj)
-      !!lazy_method_name(obj)
-    end
-
     # Return the GraphQL IDL for the schema
     # @param context [Hash]
     # @param only [<#call(member, ctx)>]
@@ -762,7 +823,7 @@ module GraphQL
     # @param except [<#call(member, ctx)>]
     # @return [Hash] GraphQL result
     def as_json(only: nil, except: nil, context: {})
-      execute(Introspection::INTROSPECTION_QUERY, only: only, except: except, context: context).to_h
+      execute(Introspection.query(include_deprecated_args: true), only: only, except: except, context: context).to_h
     end
 
     # Returns the JSON response of {Introspection::INTROSPECTION_QUERY}.
@@ -787,7 +848,6 @@ module GraphQL
       def_delegators :graphql_definition,
         # Execution
         :execution_strategy_for_operation,
-        :validate, :multiplex_analyzers,
         # Configuration
         :metadata, :redefine,
         :id_from_object_proc, :object_from_id_proc,
@@ -800,8 +860,8 @@ module GraphQL
       # Returns the JSON response of {Introspection::INTROSPECTION_QUERY}.
       # @see {#as_json}
       # @return [String]
-      def to_json(*args)
-        JSON.pretty_generate(as_json(*args))
+      def to_json(**args)
+        JSON.pretty_generate(as_json(**args))
       end
 
       # Return the Hash response of {Introspection::INTROSPECTION_QUERY}.
@@ -810,7 +870,7 @@ module GraphQL
       # @param except [<#call(member, ctx)>]
       # @return [Hash] GraphQL result
       def as_json(only: nil, except: nil, context: {})
-        execute(Introspection::INTROSPECTION_QUERY, only: only, except: except, context: context).to_h
+        execute(Introspection.query(include_deprecated_args: true), only: only, except: except, context: context).to_h
       end
 
       # Return the GraphQL IDL for the schema
@@ -875,6 +935,8 @@ module GraphQL
         schema_defn.query = query && query.graphql_definition
         schema_defn.mutation = mutation && mutation.graphql_definition
         schema_defn.subscription = subscription && subscription.graphql_definition
+        schema_defn.validate_timeout = validate_timeout
+        schema_defn.validate_max_errors = validate_max_errors
         schema_defn.max_complexity = max_complexity
         schema_defn.error_bubbling = error_bubbling
         schema_defn.max_depth = max_depth
@@ -896,6 +958,7 @@ module GraphQL
         schema_defn.cursor_encoder = cursor_encoder
         schema_defn.tracers.concat(tracers)
         schema_defn.query_analyzers.concat(query_analyzers)
+        schema_defn.analysis_engine = analysis_engine
 
         schema_defn.middleware.concat(all_middleware)
         schema_defn.multiplex_analyzers.concat(multiplex_analyzers)
@@ -913,7 +976,7 @@ module GraphQL
           schema_defn.lazy_methods.set(lazy_class, value_method)
         end
 
-        rescues.each do |err_class, handler|
+        error_handler.each_rescue do |err_class, handler|
           schema_defn.rescue_from(err_class, &handler)
         end
 
@@ -922,6 +985,11 @@ module GraphQL
         if !schema_defn.interpreter?
           schema_defn.instrumenters[:query] << GraphQL::Schema::Member::Instrumentation
         end
+
+        if new_connections?
+          schema_defn.connections = self.connections
+        end
+
         schema_defn.send(:rebuild_artifacts)
 
         schema_defn
@@ -930,20 +998,78 @@ module GraphQL
       # 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
-        non_introspection_types.merge(introspection_system.types)
+      def types(context = GraphQL::Query::NullContext)
+        all_types = non_introspection_types.merge(introspection_system.types)
+        visible_types = {}
+        all_types.each do |k, v|
+          visible_types[k] =if v.is_a?(Array)
+            visible_t = nil
+            v.each do |t|
+              if t.visible?(context)
+                if visible_t.nil?
+                  visible_t = t
+                else
+                  raise DuplicateNamesError, "Found two visible type definitions for `#{k}`: #{visible_t.inspect}, #{t.inspect}"
+                end
+              end
+            end
+            visible_t
+          else
+            v
+          end
+        end
+        visible_types
       end
 
       # @param type_name [String]
       # @return [Module, nil] A type, or nil if there's no type called `type_name`
-      def get_type(type_name)
-        own_types[type_name] ||
-          introspection_system.types[type_name] ||
-          find_inherited_value(:types, EMPTY_HASH)[type_name]
+      def get_type(type_name, context = GraphQL::Query::NullContext)
+        local_entry = own_types[type_name]
+        type_defn = case local_entry
+        when nil
+          nil
+        when Array
+          visible_t = nil
+          warden = Warden.from_context(context)
+          local_entry.each do |t|
+            if warden.visible_type?(t, context)
+              if visible_t.nil?
+                visible_t = t
+              else
+                raise DuplicateNamesError, "Found two visible type definitions for `#{type_name}`: #{visible_t.inspect}, #{t.inspect}"
+              end
+            end
+          end
+          visible_t
+        when Module
+          local_entry
+        else
+          raise "Invariant: unexpected own_types[#{type_name.inspect}]: #{local_entry.inspect}"
+        end
+
+        type_defn ||
+          introspection_system.types[type_name] || # todo context-specific introspection?
+          (superclass.respond_to?(:get_type) ? superclass.get_type(type_name, context) : nil)
       end
 
+      # @api private
+      attr_writer :connections
+
       # @return [GraphQL::Pagination::Connections] if installed
-      attr_accessor :connections
+      def connections
+        if defined?(@connections)
+          @connections
+        else
+          inherited_connections = find_inherited_value(:connections, nil)
+          # This schema is part of an inheritance chain which is using new connections,
+          # make a new instance, so we don't pollute the upstream one.
+          if inherited_connections
+            @connections = Pagination::Connections.new(schema: self)
+          else
+            nil
+          end
+        end
+      end
 
       def new_connections?
         !!connections
@@ -983,6 +1109,7 @@ module GraphQL
             raise GraphQL::Error, "Second definition of `subscription(...)` (#{new_subscription_object.inspect}) is invalid, already configured with #{@subscription_object.inspect}"
           else
             @subscription_object = new_subscription_object
+            add_subscription_extension_if_necessary
             add_type_and_traverse(new_subscription_object, root: true)
             nil
           end
@@ -991,7 +1118,7 @@ module GraphQL
         end
       end
 
-      # @see [GraphQL::Schema::Warden] Resticted access to root types
+      # @see [GraphQL::Schema::Warden] Restricted access to root types
       # @return [GraphQL::ObjectType, nil]
       def root_type_for_operation(operation)
         case operation
@@ -1019,7 +1146,17 @@ module GraphQL
           if type.kind.union?
             type.possible_types(context: context)
           else
-            own_possible_types[type.graphql_name] ||
+            stored_possible_types = own_possible_types[type.graphql_name]
+            visible_possible_types = if stored_possible_types && type.kind.interface?
+              stored_possible_types.select do |possible_type|
+                # Use `.graphql_name` comparison to match legacy vs class-based types.
+                # When we don't need to support legacy `.define` types, use `.include?(type)` instead.
+                possible_type.interfaces(context).any? { |interface| interface.graphql_name == type.graphql_name }
+              end
+            else
+              stored_possible_types
+            end
+            visible_possible_types ||
               introspection_system.possible_types[type.graphql_name] ||
               (
                 superclass.respond_to?(:possible_types) ?
@@ -1049,6 +1186,14 @@ module GraphQL
         end
       end
 
+      # @api private
+      # @see GraphQL::Dataloader
+      def dataloader_class
+        @dataloader_class || GraphQL::Dataloader::NullDataloader
+      end
+
+      attr_writer :dataloader_class
+
       def references_to(to_type = nil, from: nil)
         @own_references_to ||= Hash.new { |h, k| h[k] = [] }
         if to_type
@@ -1081,19 +1226,19 @@ module GraphQL
         GraphQL::Schema::TypeExpression.build_type(type_owner, ast_node)
       end
 
-      def get_field(type_or_name, field_name)
+      def get_field(type_or_name, field_name, context = GraphQL::Query::NullContext)
         parent_type = case type_or_name
         when LateBoundType
-          get_type(type_or_name.name)
+          get_type(type_or_name.name, context)
         when String
-          get_type(type_or_name)
+          get_type(type_or_name, context)
         when Module
           type_or_name
         else
           raise ArgumentError, "unexpected field owner for #{field_name.inspect}: #{type_or_name.inspect} (#{type_or_name.class})"
         end
 
-        if parent_type.kind.fields? && (field = parent_type.get_field(field_name))
+        if parent_type.kind.fields? && (field = parent_type.get_field(field_name, context))
           field
         elsif parent_type == query && (entry_point_field = introspection_system.entry_point(name: field_name))
           entry_point_field
@@ -1104,8 +1249,8 @@ module GraphQL
         end
       end
 
-      def get_fields(type)
-        type.fields
+      def get_fields(type, context = GraphQL::Query::NullContext)
+        type.fields(context)
       end
 
       def introspection(new_introspection_namespace = nil)
@@ -1165,6 +1310,47 @@ module GraphQL
         end
       end
 
+      attr_writer :validate_timeout
+
+      def validate_timeout(new_validate_timeout = nil)
+        if new_validate_timeout
+          @validate_timeout = new_validate_timeout
+        elsif defined?(@validate_timeout)
+          @validate_timeout
+        else
+          find_inherited_value(:validate_timeout)
+        end
+      end
+
+      # Validate a query string according to this schema.
+      # @param string_or_document [String, GraphQL::Language::Nodes::Document]
+      # @return [Array<GraphQL::StaticValidation::Error >]
+      def validate(string_or_document, rules: nil, context: nil)
+        doc = if string_or_document.is_a?(String)
+          GraphQL.parse(string_or_document)
+        else
+          string_or_document
+        end
+        query = GraphQL::Query.new(self, document: doc, context: context)
+        validator_opts = { schema: self }
+        rules && (validator_opts[:rules] = rules)
+        validator = GraphQL::StaticValidation::Validator.new(**validator_opts)
+        res = validator.validate(query, timeout: validate_timeout, max_errors: validate_max_errors)
+        res[:errors]
+      end
+
+      attr_writer :validate_max_errors
+
+      def validate_max_errors(new_validate_max_errors = nil)
+        if new_validate_max_errors
+          @validate_max_errors = new_validate_max_errors
+        elsif defined?(@validate_max_errors)
+          @validate_max_errors
+        else
+          find_inherited_value(:validate_max_errors)
+        end
+      end
+
       attr_writer :max_complexity
 
       def max_complexity(max_complexity = nil)
@@ -1180,7 +1366,7 @@ module GraphQL
       attr_writer :analysis_engine
 
       def analysis_engine
-        @analysis_engine || find_inherited_value(:analysis_engine, GraphQL::Analysis)
+        @analysis_engine || find_inherited_value(:analysis_engine, self.default_analysis_engine)
       end
 
       def using_ast_analysis?
@@ -1188,11 +1374,9 @@ module GraphQL
       end
 
       def interpreter?
-        if defined?(@interpreter)
-          @interpreter
-        else
-          find_inherited_value(:interpreter?, false)
-        end
+        query_execution_strategy == GraphQL::Execution::Interpreter &&
+          mutation_execution_strategy == GraphQL::Execution::Interpreter &&
+          subscription_execution_strategy == GraphQL::Execution::Interpreter
       end
 
       attr_writer :interpreter
@@ -1265,7 +1449,6 @@ module GraphQL
         if new_orphan_types.any?
           new_orphan_types = new_orphan_types.flatten
           add_type_and_traverse(new_orphan_types, root: false)
-          @orphan_types = new_orphan_types
           own_orphan_types.concat(new_orphan_types.flatten)
         end
 
@@ -1276,7 +1459,15 @@ module GraphQL
         if superclass <= GraphQL::Schema
           superclass.default_execution_strategy
         else
-          @default_execution_strategy ||= GraphQL::Execution::Execute
+          @default_execution_strategy ||= GraphQL::Execution::Interpreter
+        end
+      end
+
+      def default_analysis_engine
+        if superclass <= GraphQL::Schema
+          superclass.default_analysis_engine
+        else
+          @default_analysis_engine ||= GraphQL::Analysis::AST
         end
       end
 
@@ -1290,14 +1481,14 @@ module GraphQL
 
       def rescue_from(*err_classes, &handler_block)
         err_classes.each do |err_class|
-          own_rescues[err_class] = handler_block
+          error_handler.rescue_from(err_class, handler_block)
         end
       end
 
       # rubocop:disable Lint/DuplicateMethods
       module ResolveTypeWithType
         def resolve_type(type, obj, ctx)
-          first_resolved_type = if type.is_a?(Module) && type.respond_to?(:resolve_type)
+          first_resolved_type, resolved_value = if type.is_a?(Module) && type.respond_to?(:resolve_type)
             type.resolve_type(obj, ctx)
           else
             super
@@ -1305,7 +1496,11 @@ module GraphQL
 
           after_lazy(first_resolved_type) do |resolved_type|
             if resolved_type.nil? || (resolved_type.is_a?(Module) && resolved_type.respond_to?(:kind)) || resolved_type.is_a?(GraphQL::BaseType)
-              resolved_type
+              if resolved_value
+                [resolved_type, resolved_value]
+              else
+                resolved_type
+              end
             else
               raise ".resolve_type should return a type definition, but got #{resolved_type.inspect} (#{resolved_type.class}) from `resolve_type(#{type}, #{obj}, #{ctx})`"
             end
@@ -1330,10 +1525,6 @@ module GraphQL
         super
       end
 
-      def rescues
-        find_inherited_value(:rescues, EMPTY_HASH).merge(own_rescues)
-      end
-
       def object_from_id(node_id, ctx)
         raise GraphQL::RequiredImplementationMissingError, "#{self.name}.object_from_id(node_id, ctx) must be implemented to load by ID (tried to load from id `#{node_id}`)"
       end
@@ -1410,11 +1601,10 @@ module GraphQL
       def parse_error(parse_err, ctx)
         ctx.errors.push(parse_err)
       end
-      attr_writer :error_handler
 
-      # @return [GraphQL::Execution::Errors, Class<GraphQL::Execution::Errors::NullErrorHandler>]
+      # @return [GraphQL::Execution::Errors]
       def error_handler
-        @error_handler ||= GraphQL::Execution::Errors::NullErrorHandler
+        @error_handler ||= GraphQL::Execution::Errors.new(self)
       end
 
       def lazy_resolve(lazy_class, value_method)
@@ -1422,6 +1612,10 @@ module GraphQL
       end
 
       def instrument(instrument_step, instrumenter, options = {})
+        if instrument_step == :field
+          GraphQL::Deprecation.warn "Field instrumentation (#{instrumenter.inspect}) will be removed in GraphQL-Ruby 2.0, please upgrade to field extensions: https://graphql-ruby.org/type_definitions/field_extensions.html"
+        end
+
         step = if instrument_step == :field && options[:after_built_ins]
           :field_after_built_ins
         else
@@ -1433,9 +1627,9 @@ module GraphQL
 
       # Add several directives at once
       # @param new_directives [Class]
-      def directives(new_directives = nil)
-        if new_directives
-          new_directives.each { |d| directive(d) }
+      def directives(*new_directives)
+        if new_directives.any?
+          new_directives.flatten.each { |d| directive(d) }
         end
 
         find_inherited_value(:directives, default_directives).merge(own_directives)
@@ -1443,17 +1637,17 @@ module GraphQL
 
       # Attach a single directive to this schema
       # @param new_directive [Class]
+      # @return void
       def directive(new_directive)
         add_type_and_traverse(new_directive, root: false)
-        own_directives[new_directive.graphql_name] = new_directive
       end
 
       def default_directives
-        {
+        @default_directives ||= {
           "include" => GraphQL::Schema::Directive::Include,
           "skip" => GraphQL::Schema::Directive::Skip,
           "deprecated" => GraphQL::Schema::Directive::Deprecated,
-        }
+        }.freeze
       end
 
       def tracer(new_tracer)
@@ -1466,7 +1660,7 @@ module GraphQL
 
       def query_analyzer(new_analyzer)
         if new_analyzer == GraphQL::Authorization::Analyzer
-          warn("The Authorization query analyzer is deprecated. Authorizing at query runtime is generally a better idea.")
+          GraphQL::Deprecation.warn("The Authorization query analyzer is deprecated. Authorizing at query runtime is generally a better idea.")
         end
         own_query_analyzers << new_analyzer
       end
@@ -1477,6 +1671,7 @@ module GraphQL
 
       def middleware(new_middleware = nil)
         if new_middleware
+          GraphQL::Deprecation.warn "Middleware will be removed in GraphQL-Ruby 2.0, please upgrade to Field Extensions: https://graphql-ruby.org/type_definitions/field_extensions.html"
           own_middleware << new_middleware
         else
           # TODO make sure this is cached when running a query
@@ -1492,6 +1687,14 @@ module GraphQL
         find_inherited_value(:multiplex_analyzers, EMPTY_ARRAY) + own_multiplex_analyzers
       end
 
+      def sanitized_printer(new_sanitized_printer = nil)
+        if new_sanitized_printer
+          @own_sanitized_printer = new_sanitized_printer
+        else
+          @own_sanitized_printer || GraphQL::Language::SanitizedPrinter
+        end
+      end
+
       # Execute a query on itself.
       # @see {Query#initialize} for arguments.
       # @return [Hash] query result, ready to be serialized as JSON
@@ -1548,49 +1751,78 @@ module GraphQL
         end
       end
 
-      # Call the given block at the right time, either:
-      # - Right away, if `value` is not registered with `lazy_resolve`
-      # - After resolving `value`, if it's registered with `lazy_resolve` (eg, `Promise`)
       # @api private
-      def after_lazy(value)
-        if lazy?(value)
-          GraphQL::Execution::Lazy.new do
-            result = sync_lazy(value)
-            # The returned result might also be lazy, so check it, too
-            after_lazy(result) do |final_result|
-              yield(final_result) if block_given?
+      def add_subscription_extension_if_necessary
+        if interpreter? && !defined?(@subscription_extension_added) && subscription && self.subscriptions
+          @subscription_extension_added = true
+          if subscription.singleton_class.ancestors.include?(Subscriptions::SubscriptionRoot)
+            GraphQL::Deprecation.warn("`extend Subscriptions::SubscriptionRoot` is no longer required; you may remove it from #{self}'s `subscription` root type (#{subscription}).")
+          else
+            subscription.all_field_definitions.each do |field|
+              field.extension(Subscriptions::DefaultSubscriptionResolveExtension)
             end
           end
-        else
-          yield(value) if block_given?
         end
       end
 
-      # Override this method to handle lazy objects in a custom way.
-      # @param value [Object] an instance of a class registered with {.lazy_resolve}
-      # @param ctx [GraphQL::Query::Context] the context for this query
-      # @return [Object] A GraphQL-ready (non-lazy) object
-      def sync_lazy(value)
-        lazy_method = lazy_method_name(value)
-        if lazy_method
-          synced_value = value.public_send(lazy_method)
-          sync_lazy(synced_value)
-        else
-          value
-        end
+      def query_stack_error(query, err)
+        query.context.errors.push(GraphQL::ExecutionError.new("This query is too large to execute."))
       end
 
-      # @return [Symbol, nil] The method name to lazily resolve `obj`, or nil if `obj`'s class wasn't registered wtih {#lazy_resolve}.
-      def lazy_method_name(obj)
-        lazy_methods.get(obj)
-      end
+      private
 
-      # @return [Boolean] True if this object should be lazily resolved
-      def lazy?(obj)
-        !!lazy_method_name(obj)
-      end
+      # @param t [Module, Array<Module>]
+      # @return [void]
+      def add_type_and_traverse(t, root:)
+        if root
+          @root_types ||= []
+          @root_types << t
+        end
+        new_types = Array(t)
+        addition = Schema::Addition.new(schema: self, own_types: own_types, new_types: new_types)
+        addition.types.each do |name, types_entry| # rubocop:disable Development/ContextIsPassedCop -- build-time, not query-time
+          if (prev_entry = own_types[name])
+            prev_entries = case prev_entry
+            when Array
+              prev_entry
+            when Module
+              own_types[name] = [prev_entry]
+            else
+              raise "Invariant: unexpected prev_entry at #{name.inspect} when adding #{t.inspect}"
+            end
 
-      private
+            case types_entry
+            when Array
+              prev_entries.concat(types_entry)
+              prev_entries.uniq! # in case any are being re-visited
+            when Module
+              if !prev_entries.include?(types_entry)
+                prev_entries << types_entry
+              end
+            else
+              raise "Invariant: unexpected types_entry at #{name} when adding #{t.inspect}"
+            end
+          else
+            if types_entry.is_a?(Array)
+              types_entry.uniq!
+            end
+            own_types[name] = types_entry
+          end
+        end
+
+        own_possible_types.merge!(addition.possible_types) { |key, old_val, new_val| old_val + new_val }
+        own_union_memberships.merge!(addition.union_memberships)
+
+        addition.references.each { |thing, pointers|
+          pointers.each { |pointer| references_to(thing, from: pointer) }
+        }
+
+        addition.directives.each { |dir_class| own_directives[dir_class.graphql_name] = dir_class }
+
+        addition.arguments_with_default_values.each do |arg|
+          arg.validate_default_value
+        end
+      end
 
       def lazy_methods
         if !defined?(@lazy_methods)
@@ -1600,6 +1832,7 @@ module GraphQL
           else
             @lazy_methods = GraphQL::Execution::Lazy::LazyMethodMap.new
             @lazy_methods.set(GraphQL::Execution::Lazy, :value)
+            @lazy_methods.set(GraphQL::Dataloader::Request, :load)
           end
         end
         @lazy_methods
@@ -1617,10 +1850,6 @@ module GraphQL
         @own_plugins ||= []
       end
 
-      def own_rescues
-        @own_rescues ||= {}
-      end
-
       def own_orphan_types
         @own_orphan_types ||= []
       end
@@ -1660,209 +1889,14 @@ module GraphQL
       def own_multiplex_analyzers
         @own_multiplex_analyzers ||= []
       end
-
-      # @param t [Module, Array<Module>]
-      # @return [void]
-      def add_type_and_traverse(t, root:)
-        if root
-          @root_types ||= []
-          @root_types << t
-        end
-        late_types = []
-        new_types = Array(t)
-        new_types.each { |t| add_type(t, owner: nil, late_types: late_types) }
-        missed_late_types = 0
-        while (late_type_vals = late_types.shift)
-          type_owner, lt = late_type_vals
-          if lt.is_a?(String)
-            type = Member::BuildType.constantize(lt)
-            # Reset the counter, since we might succeed next go-round
-            missed_late_types = 0
-            update_type_owner(type_owner, type)
-            add_type(type, owner: type_owner, late_types: late_types)
-          elsif lt.is_a?(LateBoundType)
-            if (type = get_type(lt.graphql_name))
-              # Reset the counter, since we might succeed next go-round
-              missed_late_types = 0
-              update_type_owner(type_owner, type)
-              add_type(type, owner: type_owner, late_types: late_types)
-            else
-              missed_late_types += 1
-              # Add it back to the list, maybe we'll be able to resolve it later.
-              late_types << [type_owner, lt]
-              if missed_late_types == late_types.size
-                # We've looked at all of them and haven't resolved one.
-                raise UnresolvedLateBoundTypeError.new(type: lt)
-              else
-                # Try the next one
-              end
-            end
-          else
-            raise ArgumentError, "Unexpected late type: #{lt.inspect}"
-          end
-        end
-        nil
-      end
-
-      def update_type_owner(owner, type)
-        case owner
-        when Class
-          if owner.kind.union?
-            # It's a union with possible_types
-            # Replace the item by class name
-            owner.type_memberships.each { |tm|
-              possible_type = tm.object_type
-              if possible_type.is_a?(String) && (possible_type == type.name)
-                # This is a match of Ruby class names, not graphql names,
-                # since strings are used to refer to constants.
-                tm.object_type = type
-              elsif possible_type.is_a?(LateBoundType) && possible_type.graphql_name == type.graphql_name
-                tm.object_type = type
-              end
-            }
-            own_possible_types[owner.graphql_name] = owner.possible_types
-          elsif type.kind.interface? && owner.kind.object?
-            new_interfaces = owner.interfaces.map do |t|
-              if t.is_a?(String) && t == type.graphql_name
-                type
-              elsif t.is_a?(LateBoundType) && t.graphql_name == type.graphql_name
-                type
-              else
-                t
-              end
-            end
-            owner.implements(*new_interfaces)
-          end
-
-        when nil
-          # It's a root type
-          own_types[type.graphql_name] = type
-        when GraphQL::Schema::Field, GraphQL::Schema::Argument
-          orig_type = owner.type
-          # Apply list/non-null wrapper as needed
-          if orig_type.respond_to?(:of_type)
-            transforms = []
-            while (orig_type.respond_to?(:of_type))
-              if orig_type.kind.non_null?
-                transforms << :to_non_null_type
-              elsif orig_type.kind.list?
-                transforms << :to_list_type
-              else
-                raise "Invariant: :of_type isn't non-null or list"
-              end
-              orig_type = orig_type.of_type
-            end
-            transforms.reverse_each { |t| type = type.public_send(t) }
-          end
-          owner.type = type
-        else
-          raise "Unexpected update: #{owner.inspect} #{type.inspect}"
-        end
-      end
-
-      def add_type(type, owner:, late_types:)
-        if type.respond_to?(:metadata) && type.metadata.is_a?(Hash)
-          type_class = type.metadata[:type_class]
-          if type_class.nil?
-            raise ArgumentError, "Can't add legacy type: #{type} (#{type.class})"
-          else
-            type = type_class
-          end
-        elsif type.is_a?(String) || type.is_a?(GraphQL::Schema::LateBoundType)
-          late_types << [owner, type]
-          return
-        end
-
-        if owner.is_a?(Class) && owner < GraphQL::Schema::Union
-          um = own_union_memberships[type.graphql_name] ||= []
-          um << owner
-        end
-
-        if (prev_type = own_types[type.graphql_name])
-          if prev_type != type
-            raise ArgumentError, "Conflicting type definitions for `#{type.graphql_name}`: #{prev_type} (#{prev_type.class}), #{type} #{type.class}"
-          else
-            # This type was already added
-          end
-        elsif type.is_a?(Class) && type < GraphQL::Schema::Directive
-          type.arguments.each do |_name, arg|
-            arg_type = arg.type.unwrap
-            references_to(arg_type, from: arg)
-            add_type(arg_type, owner: arg, late_types: late_types)
-          end
-        else
-          own_types[type.graphql_name] = type
-          if type.kind.fields?
-            type.fields.each do |_name, field|
-              field_type = field.type.unwrap
-              references_to(field_type, from: field)
-              add_type(field_type, owner: field, late_types: late_types)
-              field.arguments.each do |_name, arg|
-                arg_type = arg.type.unwrap
-                references_to(arg_type, from: arg)
-                add_type(arg_type, owner: arg, late_types: late_types)
-              end
-            end
-          end
-          if type.kind.input_object?
-            type.arguments.each do |_name, arg|
-              arg_type = arg.type.unwrap
-              references_to(arg_type, from: arg)
-              add_type(arg_type, owner: arg, late_types: late_types)
-            end
-          end
-          if type.kind.union?
-            own_possible_types[type.graphql_name] = type.possible_types
-            type.possible_types.each do |t|
-              add_type(t, owner: type, late_types: late_types)
-            end
-          end
-          if type.kind.interface?
-            type.orphan_types.each do |t|
-              add_type(t, owner: type, late_types: late_types)
-            end
-          end
-          if type.kind.object?
-            own_possible_types[type.graphql_name] = [type]
-            type.interfaces.each do |i|
-              implementers = own_possible_types[i.graphql_name] ||= []
-              implementers << type
-              add_type(i, owner: type, late_types: late_types)
-            end
-          end
-        end
-      end
     end
 
-    # Call the given block at the right time, either:
-    # - Right away, if `value` is not registered with `lazy_resolve`
-    # - After resolving `value`, if it's registered with `lazy_resolve` (eg, `Promise`)
-    # @api private
-    def after_lazy(value)
-      if lazy?(value)
-        GraphQL::Execution::Lazy.new do
-          result = sync_lazy(value)
-          # The returned result might also be lazy, so check it, too
-          after_lazy(result) do |final_result|
-            yield(final_result) if block_given?
-          end
-        end
-      else
-        yield(value) if block_given?
-      end
+    def dataloader_class
+      self.class.dataloader_class
     end
 
-    # @see Schema.sync_lazy for a hook to override
-    # @api private
-    def sync_lazy(value)
-      lazy_method = lazy_method_name(value)
-      if lazy_method
-        synced_value = value.public_send(lazy_method)
-        sync_lazy(synced_value)
-      else
-        value
-      end
-    end
+    # Install these here so that subclasses will also install it.
+    use(GraphQL::Pagination::Connections)
 
     protected