graphql 1.12.12 → 2.4.8

data/lib/graphql/schema.rb

@@ -1,24 +1,16 @@
 # frozen_string_literal: true
+require "logger"
 require "graphql/schema/addition"
+require "graphql/schema/always_visible"
 require "graphql/schema/base_64_encoder"
-require "graphql/schema/catchall_middleware"
-require "graphql/schema/default_parse_error"
-require "graphql/schema/default_type_error"
 require "graphql/schema/find_inherited_value"
 require "graphql/schema/finder"
-require "graphql/schema/invalid_type_error"
 require "graphql/schema/introspection_system"
 require "graphql/schema/late_bound_type"
-require "graphql/schema/middleware_chain"
 require "graphql/schema/null_mask"
-require "graphql/schema/possible_types"
-require "graphql/schema/rescue_middleware"
 require "graphql/schema/timeout"
-require "graphql/schema/timeout_middleware"
-require "graphql/schema/traversal"
 require "graphql/schema/type_expression"
 require "graphql/schema/unique_within_type"
-require "graphql/schema/validation"
 require "graphql/schema/warden"
 require "graphql/schema/build_from_definition"
 
@@ -40,16 +32,20 @@ require "graphql/schema/union"
 require "graphql/schema/directive"
 require "graphql/schema/directive/deprecated"
 require "graphql/schema/directive/include"
+require "graphql/schema/directive/one_of"
 require "graphql/schema/directive/skip"
 require "graphql/schema/directive/feature"
 require "graphql/schema/directive/flagged"
 require "graphql/schema/directive/transform"
+require "graphql/schema/directive/specified_by"
 require "graphql/schema/type_membership"
 
 require "graphql/schema/resolver"
 require "graphql/schema/mutation"
+require "graphql/schema/has_single_input_argument"
 require "graphql/schema/relay_classic_mutation"
 require "graphql/schema/subscription"
+require "graphql/schema/visibility"
 
 module GraphQL
   # A GraphQL schema which may be queried with {GraphQL::Query}.
@@ -67,10 +63,6 @@ module GraphQL
   # Schemas can restrict large incoming queries with `max_depth` and `max_complexity` configurations.
   # (These configurations can be overridden by specific calls to {Schema#execute})
   #
-  # Schemas can specify how queries should be executed against them.
-  # `query_execution_strategy`, `mutation_execution_strategy` and `subscription_execution_strategy`
-  # each apply to corresponding root types.
-  #  #
   # @example defining a schema
   #   class MySchema < GraphQL::Schema
   #     query QueryType
@@ -79,16 +71,19 @@ module GraphQL
   #   end
   #
   class Schema
-    extend Forwardable
-    extend GraphQL::Schema::Member::AcceptsDefinition
     extend GraphQL::Schema::Member::HasAstNode
-    include GraphQL::Define::InstanceDefinable
-    extend GraphQL::Define::InstanceDefinable::DeprecatedDefine
     extend GraphQL::Schema::FindInheritedValue
+    extend Autoload
 
-    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(".")}")
+    autoload :BUILT_IN_TYPES, "graphql/schema/built_in_types"
+
+    class DuplicateNamesError < GraphQL::Error
+      attr_reader :duplicated_name
+      def initialize(duplicated_name:, duplicated_definition_1:, duplicated_definition_2:)
+        @duplicated_name = duplicated_name
+        super(
+          "Found two visible definitions for `#{duplicated_name}`: #{duplicated_definition_1}, #{duplicated_definition_2}"
+        )
       end
     end
 
@@ -100,760 +95,165 @@ 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
+    # Error that is raised when [#Schema#from_definition] is passed an invalid schema definition string.
+    class InvalidDocumentError < Error; end;
+
+    class << self
+      # Create schema with the result of an introspection query.
+      # @param introspection_result [Hash] A response from {GraphQL::Introspection::INTROSPECTION_QUERY}
+      # @return [Class<GraphQL::Schema>] the schema described by `input`
+      def from_introspection(introspection_result)
+        GraphQL::Schema::Loader.load(introspection_result)
+      end
+
+      # Create schema from an IDL schema or file containing an IDL definition.
+      # @param definition_or_path [String] A schema definition string, or a path to a file containing the definition
+      # @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)`
+      # @return [Class] the schema described by `document`
+      def from_definition(definition_or_path, default_resolve: nil, parser: GraphQL.default_parser, using: {})
+        # If the file ends in `.graphql` or `.graphqls`, treat it like a filepath
+        if definition_or_path.end_with?(".graphql") || definition_or_path.end_with?(".graphqls")
+          GraphQL::Schema::BuildFromDefinition.from_definition_path(
+            self,
+            definition_or_path,
+            default_resolve: default_resolve,
+            parser: parser,
+            using: using,
+          )
         else
-          yield(value) if block_given?
+          GraphQL::Schema::BuildFromDefinition.from_definition(
+            self,
+            definition_or_path,
+            default_resolve: default_resolve,
+            parser: parser,
+            using: using,
+          )
         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
+      def deprecated_graphql_definition
+        graphql_definition(silence_deprecation_warning: true)
       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)
+      # @return [GraphQL::Subscriptions]
+      def subscriptions(inherited: true)
+        defined?(@subscriptions) ? @subscriptions : (inherited ? find_inherited_value(:subscriptions, nil) : nil)
       end
 
-      # @return [Boolean] True if this object should be lazily resolved
-      def lazy?(obj)
-        !!lazy_method_name(obj)
+      def subscriptions=(new_implementation)
+        @subscriptions = new_implementation
       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
+      # @param new_mode [Symbol] If configured, this will be used when `context: { trace_mode: ... }` isn't set.
+      def default_trace_mode(new_mode = nil)
+        if new_mode
+          @default_trace_mode = new_mode
+        elsif defined?(@default_trace_mode)
+          @default_trace_mode
+        elsif superclass.respond_to?(:default_trace_mode)
+          superclass.default_trace_mode
         else
-          yield maybe_lazies
+          :default
         end
       end
-    end
-
-    include LazyHandlingMethods
-    extend LazyHandlingMethods
-
-    accepts_definitions \
-      :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
-      :validate_timeout, :max_depth, :max_complexity, :default_max_page_size,
-      :orphan_types, :resolve_type, :type_error, :parse_error,
-      :error_bubbling,
-      :raise_definition_error,
-      :object_from_id, :id_from_object,
-      :default_mask,
-      :cursor_encoder,
-      # If these are given as classes, normalize them. Accept `nil` when building from string.
-      query: ->(schema, t) { schema.query = t.respond_to?(:graphql_definition) ? t.graphql_definition : t },
-      mutation: ->(schema, t) { schema.mutation = t.respond_to?(:graphql_definition) ? t.graphql_definition : t },
-      subscription: ->(schema, t) { schema.subscription = t.respond_to?(:graphql_definition) ? t.graphql_definition : t },
-      disable_introspection_entry_points: ->(schema) { schema.disable_introspection_entry_points = true },
-      disable_schema_introspection_entry_point: ->(schema) { schema.disable_schema_introspection_entry_point = true },
-      disable_type_introspection_entry_point: ->(schema) { schema.disable_type_introspection_entry_point = true },
-      directives: ->(schema, directives) { schema.directives = directives.reduce({}) { |m, d| m[d.graphql_name] = d; m } },
-      directive: ->(schema, directive) { schema.directives[directive.graphql_name] = directive },
-      instrument: ->(schema, type, instrumenter, after_built_ins: false) {
-        if type == :field && after_built_ins
-          type = :field_after_built_ins
-        end
-        schema.instrumenters[type] << instrumenter
-      },
-      query_analyzer: ->(schema, analyzer) {
-        if analyzer == GraphQL::Authorization::Analyzer
-          GraphQL::Deprecation.warn("The Authorization query analyzer is deprecated. Authorizing at query runtime is generally a better idea.")
-        end
-        schema.query_analyzers << analyzer
-      },
-      multiplex_analyzer: ->(schema, analyzer) { schema.multiplex_analyzers << analyzer },
-      middleware: ->(schema, middleware) { schema.middleware << middleware },
-      lazy_resolve: ->(schema, lazy_class, lazy_value_method) { schema.lazy_methods.set(lazy_class, lazy_value_method) },
-      rescue_from: ->(schema, err_class, &block) { schema.rescue_from(err_class, &block) },
-      tracer: ->(schema, tracer) { schema.tracers.push(tracer) }
-
-    ensure_defined :introspection_system
-
-    attr_accessor \
-      :query, :mutation, :subscription,
-      :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
-      :validate_timeout, :max_depth, :max_complexity, :default_max_page_size,
-      :orphan_types, :directives,
-      :query_analyzers, :multiplex_analyzers, :instrumenters, :lazy_methods,
-      :cursor_encoder,
-      :ast_node,
-      :raise_definition_error,
-      :introspection_namespace,
-      :analysis_engine
-
-    # [Boolean] True if this object bubbles validation errors up from a field into its parent InputObject, if there is one.
-    attr_accessor :error_bubbling
-
-    # Single, long-lived instance of the provided subscriptions class, if there is one.
-    # @return [GraphQL::Subscriptions]
-    attr_accessor :subscriptions
-
-    # @return [MiddlewareChain] MiddlewareChain which is applied to fields during execution
-    attr_accessor :middleware
-
-    # @return [<#call(member, ctx)>] A callable for filtering members of the schema
-    # @see {Query.new} for query-specific filters with `except:`
-    attr_accessor :default_mask
-
-    # @see {GraphQL::Query::Context} The parent class of these classes
-    # @return [Class] Instantiated for each query
-    attr_accessor :context_class
-
-    # [Boolean] True if this object disables the introspection entry point fields
-    attr_accessor :disable_introspection_entry_points
-
-    def disable_introspection_entry_points?
-      !!@disable_introspection_entry_points
-    end
-
-    # [Boolean] True if this object disables the __schema introspection entry point field
-    attr_accessor :disable_schema_introspection_entry_point
-
-    def disable_schema_introspection_entry_point?
-      !!@disable_schema_introspection_entry_point
-    end
-
-    # [Boolean] True if this object disables the __type introspection entry point field
-    attr_accessor :disable_type_introspection_entry_point
-
-    def disable_type_introspection_entry_point?
-      !!@disable_type_introspection_entry_point
-    end
-
-    class << self
-      attr_writer :default_execution_strategy
-    end
-
-    def default_filter
-      GraphQL::Filter.new(except: default_mask)
-    end
-
-    # @return [Array<#trace(key, data)>] Tracers applied to every query
-    # @see {Query#tracers} for query-specific tracers
-    attr_reader :tracers
-
-    DYNAMIC_FIELDS = ["__type", "__typename", "__schema"].freeze
-
-    attr_reader :static_validator, :object_from_id_proc, :id_from_object_proc, :resolve_type_proc
-
-    def initialize
-      @tracers = []
-      @definition_error = nil
-      @orphan_types = []
-      @directives = {}
-      self.class.default_directives.each do |name, dir|
-        @directives[name] = dir.graphql_definition
-      end
-      @static_validator = GraphQL::StaticValidation::Validator.new(schema: self)
-      @middleware = MiddlewareChain.new(final_step: GraphQL::Execution::Execute::FieldResolveStep)
-      @query_analyzers = []
-      @multiplex_analyzers = []
-      @resolve_type_proc = nil
-      @object_from_id_proc = nil
-      @id_from_object_proc = nil
-      @type_error_proc = DefaultTypeError
-      @parse_error_proc = DefaultParseError
-      @instrumenters = Hash.new { |h, k| h[k] = [] }
-      @lazy_methods = GraphQL::Execution::Lazy::LazyMethodMap.new
-      @lazy_methods.set(GraphQL::Execution::Lazy, :value)
-      @cursor_encoder = Base64Encoder
-      # For schema instances, default to legacy runtime modules
-      @analysis_engine = GraphQL::Analysis
-      @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
-      @introspection_namespace = nil
-      @introspection_system = nil
-      @interpreter = false
-      @error_bubbling = false
-      @disable_introspection_entry_points = false
-      @disable_schema_introspection_entry_point = false
-      @disable_type_introspection_entry_point = false
-    end
-
-    # @return [Boolean] True if using the new {GraphQL::Execution::Interpreter}
-    def interpreter?
-      query_execution_strategy == GraphQL::Execution::Interpreter &&
-        mutation_execution_strategy == GraphQL::Execution::Interpreter &&
-        subscription_execution_strategy == GraphQL::Execution::Interpreter
-    end
-
-    def inspect
-      "#<#{self.class.name} ...>"
-    end
-
-    def initialize_copy(other)
-      super
-      @orphan_types = other.orphan_types.dup
-      @directives = other.directives.dup
-      @static_validator = GraphQL::StaticValidation::Validator.new(schema: self)
-      @middleware = other.middleware.dup
-      @query_analyzers = other.query_analyzers.dup
-      @multiplex_analyzers = other.multiplex_analyzers.dup
-      @tracers = other.tracers.dup
-      @possible_types = GraphQL::Schema::PossibleTypes.new(self)
-
-      @lazy_methods = other.lazy_methods.dup
-
-      @instrumenters = Hash.new { |h, k| h[k] = [] }
-      other.instrumenters.each do |key, insts|
-        @instrumenters[key].concat(insts)
-      end
-
-      if other.rescues?
-        @rescue_middleware = other.rescue_middleware
-      end
-
-      # This will be rebuilt when it's requested
-      # or during a later `define` call
-      @types = nil
-      @introspection_system = nil
-    end
-
-    def rescue_from(*args, &block)
-      rescue_middleware.rescue_from(*args, &block)
-    end
-
-    def remove_handler(*args, &block)
-      rescue_middleware.remove_handler(*args, &block)
-    end
-
-    def using_ast_analysis?
-      @analysis_engine == GraphQL::Analysis::AST
-    end
-
-    # For forwards-compatibility with Schema classes
-    alias :graphql_definition :itself
-
-    def deprecated_define(**kwargs, &block)
-      super
-      ensure_defined
-      # Assert that all necessary configs are present:
-      validation_error = Validation.validate(self)
-      validation_error && raise(GraphQL::RequiredImplementationMissingError, validation_error)
-      rebuild_artifacts
-
-      @definition_error = nil
-      nil
-    rescue StandardError => err
-      if @raise_definition_error || err.is_a?(CyclicalDefinitionError) || err.is_a?(GraphQL::RequiredImplementationMissingError)
-        raise
-      else
-        # Raise this error _later_ to avoid messing with Rails constant loading
-        @definition_error = err
-      end
-      nil
-    end
-
-    # Attach `instrumenter` to this schema for instrumenting events of `instrumentation_type`.
-    # @param instrumentation_type [Symbol]
-    # @param instrumenter
-    # @return [void]
-    def instrument(instrumentation_type, instrumenter)
-      @instrumenters[instrumentation_type] << instrumenter
-      if instrumentation_type == :field
-        rebuild_artifacts
-      end
-    end
-
-    # @return [Array<GraphQL::BaseType>] The root types of this schema
-    def root_types
-      @root_types ||= begin
-        rebuild_artifacts
-        @root_types
-      end
-    end
-
-    # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
-    # @return [GraphQL::Schema::TypeMap] `{ name => type }` pairs of types in this schema
-    def types
-      @types ||= begin
-        rebuild_artifacts
-        @types
-      end
-    end
 
-    def get_type(type_name)
-      @types[type_name]
-    end
-
-    # @api private
-    def introspection_system
-      @introspection_system ||= begin
-        rebuild_artifacts
-        @introspection_system
-      end
-    end
-
-    # Returns a list of Arguments and Fields referencing a certain type
-    # @param type_name [String]
-    # @return [Hash]
-    def references_to(type_name = nil)
-      rebuild_artifacts unless defined?(@type_reference_map)
-      if type_name
-        @type_reference_map.fetch(type_name, [])
-      else
-        @type_reference_map
-      end
-    end
-
-    # Returns a list of Union types in which a type is a member
-    # @param type [GraphQL::ObjectType]
-    # @return [Array<GraphQL::UnionType>] list of union types of which the type is a member
-    def union_memberships(type)
-      rebuild_artifacts unless defined?(@union_memberships)
-      @union_memberships.fetch(type.name, [])
-    end
-
-    # Execute a query on itself. Raises an error if the schema definition is invalid.
-    # @see {Query#initialize} for arguments.
-    # @return [Hash] query result, ready to be serialized as JSON
-    def execute(query_str = nil, **kwargs)
-      if query_str
-        kwargs[:query] = query_str
-      end
-      # Some of the query context _should_ be passed to the multiplex, too
-      multiplex_context = if (ctx = kwargs[:context])
-        {
-          backtrace: ctx[:backtrace],
-          tracers: ctx[:tracers],
-        }
-      else
-        {}
+      def trace_class(new_class = nil)
+        if new_class
+          # If any modules were already added for `:default`,
+          # re-apply them here
+          mods = trace_modules_for(:default)
+          mods.each { |mod| new_class.include(mod) }
+          new_class.include(DefaultTraceClass)
+          trace_mode(:default, new_class)
+          backtrace_class = Class.new(new_class)
+          backtrace_class.include(GraphQL::Backtrace::Trace)
+          trace_mode(:default_backtrace, backtrace_class)
+        end
+        trace_class_for(:default, build: true)
       end
-      # Since we're running one query, don't run a multiplex-level complexity analyzer
-      all_results = multiplex([kwargs], max_complexity: nil, context: multiplex_context)
-      all_results[0]
-    end
 
-    # Execute several queries on itself. Raises an error if the schema definition is invalid.
-    # @example Run several queries at once
-    #   context = { ... }
-    #   queries = [
-    #     { query: params[:query_1], variables: params[:variables_1], context: context },
-    #     { query: params[:query_2], variables: params[:variables_2], context: context },
-    #   ]
-    #   results = MySchema.multiplex(queries)
-    #   render json: {
-    #     result_1: results[0],
-    #     result_2: results[1],
-    #   }
-    #
-    # @see {Query#initialize} for query keyword arguments
-    # @see {Execution::Multiplex#run_queries} for multiplex keyword arguments
-    # @param queries [Array<Hash>] Keyword arguments for each query
-    # @param context [Hash] Multiplex-level context
-    # @return [Array<Hash>] One result for each query in the input
-    def multiplex(queries, **kwargs)
-      with_definition_error_check {
-        GraphQL::Execution::Multiplex.run_all(self, queries, **kwargs)
-      }
-    end
-
-    # Search for a schema member using a string path
-    # @example Finding a Field
-    # Schema.find("Ensemble.musicians")
-    #
-    # @see {GraphQL::Schema::Finder} for more examples
-    # @param path [String] A dot-separated path to the member
-    # @raise [Schema::Finder::MemberNotFoundError] if path could not be found
-    # @return [GraphQL::BaseType, GraphQL::Field, GraphQL::Argument, GraphQL::Directive] A GraphQL Schema Member
-    def find(path)
-      rebuild_artifacts unless defined?(@finder)
-      @find_cache[path] ||= @finder.find(path)
-    end
-
-    # Resolve field named `field_name` for type `parent_type`.
-    # Handles dynamic fields `__typename`, `__type` and `__schema`, too
-    # @param parent_type [String, GraphQL::BaseType]
-    # @param field_name [String]
-    # @return [GraphQL::Field, nil] The field named `field_name` on `parent_type`
-    # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
-    def get_field(parent_type, field_name)
-      with_definition_error_check do
-        parent_type_name = case parent_type
-        when GraphQL::BaseType, Class, Module
-          parent_type.graphql_name
-        when String
-          parent_type
-        else
-          raise "Unexpected parent_type: #{parent_type}"
-        end
-
-        defined_field = @instrumented_field_map[parent_type_name][field_name]
-        if defined_field
-          defined_field
-        elsif parent_type == query && (entry_point_field = introspection_system.entry_point(name: field_name))
-          entry_point_field
-        elsif (dynamic_field = introspection_system.dynamic_field(name: field_name))
-          dynamic_field
+      # @return [Class] Return the trace class to use for this mode, looking one up on the superclass if this Schema doesn't have one defined.
+      def trace_class_for(mode, build: false)
+        if (trace_class = own_trace_modes[mode])
+          trace_class
+        elsif superclass.respond_to?(:trace_class_for) && (trace_class = superclass.trace_class_for(mode, build: false))
+          trace_class
+        elsif build
+          own_trace_modes[mode] = build_trace_mode(mode)
         else
           nil
         end
       end
-    end
-
-    # Fields for this type, after instrumentation is applied
-    # @return [Hash<String, GraphQL::Field>]
-    def get_fields(type)
-      @instrumented_field_map[type.graphql_name]
-    end
-
-    def type_from_ast(ast_node, context:)
-      GraphQL::Schema::TypeExpression.build_type(self, ast_node)
-    end
-
-    # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
-    # @param type_defn [GraphQL::InterfaceType, GraphQL::UnionType] the type whose members you want to retrieve
-    # @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)
-      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
-    # @return [GraphQL::ObjectType, nil]
-    def root_type_for_operation(operation)
-      case operation
-      when "query"
-        query
-      when "mutation"
-        mutation
-      when "subscription"
-        subscription
-      else
-        raise ArgumentError, "unknown operation type: #{operation}"
-      end
-    end
-
-    def execution_strategy_for_operation(operation)
-      case operation
-      when "query"
-        query_execution_strategy
-      when "mutation"
-        mutation_execution_strategy
-      when "subscription"
-        subscription_execution_strategy
-      else
-        raise ArgumentError, "unknown operation type: #{operation}"
-      end
-    end
-
-    # Determine the GraphQL type for a given object.
-    # This is required for unions and interfaces (including Relay's `Node` interface)
-    # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
-    # @param type [GraphQL::UnionType, GraphQL:InterfaceType] the abstract type which is being resolved
-    # @param object [Any] An application object which GraphQL is currently resolving on
-    # @param ctx [GraphQL::Query::Context] The context for the current query
-    # @return [GraphQL::ObjectType] The type for exposing `object` in GraphQL
-    def resolve_type(type, object, ctx = :__undefined__)
-      check_resolved_type(type, object, ctx) do |ok_type, ok_object, ok_ctx|
-        if @resolve_type_proc.nil?
-          raise(GraphQL::RequiredImplementationMissingError, "Can't determine GraphQL type for: #{ok_object.inspect}, define `resolve_type (type, obj, ctx) -> { ... }` inside `Schema.define`.")
-        end
-        @resolve_type_proc.call(ok_type, ok_object, ok_ctx)
-      end
-    end
-
-    # This is a compatibility hack so that instance-level and class-level
-    # methods can get correctness checks without calling one another
-    # @api private
-    def check_resolved_type(type, object, ctx = :__undefined__)
-      if ctx == :__undefined__
-        # Old method signature
-        ctx = object
-        object = type
-        type = nil
-      end
-
-      if object.is_a?(GraphQL::Schema::Object)
-        object = object.object
-      end
 
-      if type.respond_to?(:graphql_definition)
-        type = type.graphql_definition
+      # Configure `trace_class` to be used whenever `context: { trace_mode: mode_name }` is requested.
+      # {default_trace_mode} is used when no `trace_mode: ...` is requested.
+      #
+      # When a `trace_class` is added this way, it will _not_ receive other modules added with `trace_with(...)`
+      # unless `trace_mode` is explicitly given. (This class will not receive any default trace modules.)
+      #
+      # Subclasses of the schema will use `trace_class` as a base class for this mode and those
+      # subclass also will _not_ receive default tracing modules.
+      #
+      # @param mode_name [Symbol]
+      # @param trace_class [Class] subclass of GraphQL::Tracing::Trace
+      # @return void
+      def trace_mode(mode_name, trace_class)
+        own_trace_modes[mode_name] = trace_class
+        nil
       end
 
-      # Prefer a type-local function; fall back to the schema-level function
-      type_proc = type && type.resolve_type_proc
-      type_result = if type_proc
-        type_proc.call(object, ctx)
-      else
-        yield(type, object, ctx)
+      def own_trace_modes
+        @own_trace_modes ||= {}
       end
 
-      if type_result.nil?
-        nil
-      else
-        after_lazy(type_result) do |resolved_type_result|
-          if resolved_type_result.respond_to?(:graphql_definition)
-            resolved_type_result = resolved_type_result.graphql_definition
+      def build_trace_mode(mode)
+        case mode
+        when :default
+          # Use the superclass's default mode if it has one, or else start an inheritance chain at the built-in base class.
+          base_class = (superclass.respond_to?(:trace_class_for) && superclass.trace_class_for(mode, build: true)) || GraphQL::Tracing::Trace
+          const_set(:DefaultTrace, Class.new(base_class) do
+            include DefaultTraceClass
+          end)
+        when :default_backtrace
+          schema_base_class = trace_class_for(:default, build: true)
+          const_set(:DefaultTraceBacktrace, Class.new(schema_base_class) do
+            include(GraphQL::Backtrace::Trace)
+          end)
+        else
+          # First, see if the superclass has a custom-defined class for this.
+          # Then, if it doesn't, use this class's default trace
+          base_class = (superclass.respond_to?(:trace_class_for) && superclass.trace_class_for(mode)) || trace_class_for(:default, build: true)
+          # Prepare the default trace class if it hasn't been initialized yet
+          base_class ||= (own_trace_modes[:default] = build_trace_mode(:default))
+          mods = trace_modules_for(mode)
+          if base_class < DefaultTraceClass
+            mods = trace_modules_for(:default) + mods
           end
-          if !resolved_type_result.is_a?(GraphQL::BaseType)
-            type_str = "#{resolved_type_result} (#{resolved_type_result.class.name})"
-            raise "resolve_type(#{object}) returned #{type_str}, but it should return a GraphQL type"
-          else
-            resolved_type_result
+          # Copy the existing default options into this mode's options
+          default_options = trace_options_for(:default)
+          add_trace_options_for(mode, default_options)
+
+          Class.new(base_class) do
+            !mods.empty? && include(*mods)
           end
         end
       end
-    end
-
-    def resolve_type=(new_resolve_type_proc)
-      callable = GraphQL::BackwardsCompatibility.wrap_arity(new_resolve_type_proc, from: 2, to: 3, last: true, name: "Schema#resolve_type(type, obj, ctx)")
-      @resolve_type_proc = callable
-    end
-
-    # Fetch an application object by its unique id
-    # @param id [String] A unique identifier, provided previously by this GraphQL schema
-    # @param ctx [GraphQL::Query::Context] The context for the current query
-    # @return [Any] The application object identified by `id`
-    def object_from_id(id, ctx)
-      if @object_from_id_proc.nil?
-        raise(GraphQL::RequiredImplementationMissingError, "Can't fetch an object for id \"#{id}\" because the schema's `object_from_id (id, ctx) -> { ... }` function is not defined")
-      else
-        @object_from_id_proc.call(id, ctx)
-      end
-    end
-
-    # @param new_proc [#call] A new callable for fetching objects by ID
-    def object_from_id=(new_proc)
-      @object_from_id_proc = new_proc
-    end
-
-    # When we encounter a type error during query execution, we call this hook.
-    #
-    # You can use this hook to write a log entry,
-    # add a {GraphQL::ExecutionError} to the response (with `ctx.add_error`)
-    # or raise an exception and halt query execution.
-    #
-    # @example A `nil` is encountered by a non-null field
-    #   type_error ->(err, query_ctx) {
-    #     err.is_a?(GraphQL::InvalidNullError) # => true
-    #   }
-    #
-    # @example An object doesn't resolve to one of a {UnionType}'s members
-    #   type_error ->(err, query_ctx) {
-    #     err.is_a?(GraphQL::UnresolvedTypeError) # => true
-    #   }
-    #
-    # @see {DefaultTypeError} is the default behavior.
-    # @param err [GraphQL::TypeError] The error encountered during execution
-    # @param ctx [GraphQL::Query::Context] The context for the field where the error occurred
-    # @return void
-    def type_error(err, ctx)
-      @type_error_proc.call(err, ctx)
-    end
-
-    # @param new_proc [#call] A new callable for handling type errors during execution
-    def type_error=(new_proc)
-      @type_error_proc = new_proc
-    end
-
-    # Can't delegate to `class`
-    alias :_schema_class :class
-    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
-    # whose `method_name` should be treated as an application hook
-    # @see {.visible?}
-    # @see {.accessible?}
-    def call_on_type_class(member, method_name, context, default:)
-      member = if member.respond_to?(:type_class)
-        member.type_class
-      else
-        member
-      end
-
-      if member.respond_to?(:relay_node_type) && (t = member.relay_node_type)
-        member = t
-      end
 
-      if member.respond_to?(method_name)
-        member.public_send(method_name, context)
-      else
-        default
+      def own_trace_modules
+        @own_trace_modules ||= Hash.new { |h, k| h[k] = [] }
       end
-    end
 
-    def visible?(member, context)
-      call_on_type_class(member, :visible?, context, default: true)
-    end
-
-    def accessible?(member, context)
-      call_on_type_class(member, :accessible?, context, default: true)
-    end
-
-    # A function to call when {#execute} receives an invalid query string
-    #
-    # @see {DefaultParseError} is the default behavior.
-    # @param err [GraphQL::ParseError] The error encountered during parsing
-    # @param ctx [GraphQL::Query::Context] The context for the query where the error occurred
-    # @return void
-    def parse_error(err, ctx)
-      @parse_error_proc.call(err, ctx)
-    end
-
-    # @param new_proc [#call] A new callable for handling parse errors during execution
-    def parse_error=(new_proc)
-      @parse_error_proc = new_proc
-    end
-
-    # Get a unique identifier from this object
-    # @param object [Any] An application object
-    # @param type [GraphQL::BaseType] The current type definition
-    # @param ctx [GraphQL::Query::Context] the context for the current query
-    # @return [String] a unique identifier for `object` which clients can use to refetch it
-    def id_from_object(object, type, ctx)
-      if @id_from_object_proc.nil?
-        raise(GraphQL::RequiredImplementationMissingError, "Can't generate an ID for #{object.inspect} of type #{type}, schema's `id_from_object` must be defined")
-      else
-        @id_from_object_proc.call(object, type, ctx)
-      end
-    end
-
-    # @param new_proc [#call] A new callable for generating unique IDs
-    def id_from_object=(new_proc)
-      @id_from_object_proc = new_proc
-    end
-
-    # Create schema with the result of an introspection query.
-    # @param introspection_result [Hash] A response from {GraphQL::Introspection::INTROSPECTION_QUERY}
-    # @return [GraphQL::Schema] the schema described by `input`
-    def self.from_introspection(introspection_result)
-      GraphQL::Schema::Loader.load(introspection_result)
-    end
-
-    # Create schema from an IDL schema or file containing an IDL definition.
-    # @param definition_or_path [String] A schema definition string, or a path to a file containing the definition
-    # @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)`
-    # @return [Class] the schema described by `document`
-    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
-      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
-        GraphQL::Schema::BuildFromDefinition.from_definition(
-          definition_or_path,
-          default_resolve: default_resolve,
-          parser: parser,
-          using: using,
-        )
+      # @return [Array<Module>] Modules added for tracing in `trace_mode`, including inherited ones
+      def trace_modules_for(trace_mode)
+        modules = own_trace_modules[trace_mode]
+        if superclass.respond_to?(:trace_modules_for)
+          modules += superclass.trace_modules_for(trace_mode)
+        end
+        modules
       end
-    end
 
-    # Error that is raised when [#Schema#from_definition] is passed an invalid schema definition string.
-    class InvalidDocumentError < Error; end;
-
-    # Return the GraphQL IDL for the schema
-    # @param context [Hash]
-    # @param only [<#call(member, ctx)>]
-    # @param except [<#call(member, ctx)>]
-    # @return [String]
-    def to_definition(only: nil, except: nil, context: {})
-      GraphQL::Schema::Printer.print_schema(self, only: only, except: except, context: context)
-    end
-
-    # Return the GraphQL::Language::Document IDL AST for the schema
-    # @param context [Hash]
-    # @param only [<#call(member, ctx)>]
-    # @param except [<#call(member, ctx)>]
-    # @return [GraphQL::Language::Document]
-    def to_document(only: nil, except: nil, context: {})
-      GraphQL::Language::DocumentFromSchemaDefinition.new(self, only: only, except: except, context: context).document
-    end
-
-    # Return the Hash response of {Introspection::INTROSPECTION_QUERY}.
-    # @param context [Hash]
-    # @param only [<#call(member, ctx)>]
-    # @param except [<#call(member, ctx)>]
-    # @return [Hash] GraphQL result
-    def as_json(only: nil, except: nil, context: {})
-      execute(Introspection.query(include_deprecated_args: true), only: only, except: except, context: context).to_h
-    end
-
-    # Returns the JSON response of {Introspection::INTROSPECTION_QUERY}.
-    # @see {#as_json}
-    # @return [String]
-    def to_json(*args)
-      JSON.pretty_generate(as_json(*args))
-    end
-
-    def new_connections?
-      !!connections
-    end
-
-    attr_accessor :connections
-
-    class << self
-      extend Forwardable
-      # For compatibility, these methods all:
-      # - Cause the Schema instance to be created, if it hasn't been created yet
-      # - Delegate to that instance
-      # Eventually, the methods will be moved into this class, removing the need for the singleton.
-      def_delegators :graphql_definition,
-        # Execution
-        :execution_strategy_for_operation,
-        # Configuration
-        :metadata, :redefine,
-        :id_from_object_proc, :object_from_id_proc,
-        :id_from_object=, :object_from_id=,
-        :remove_handler
-
-      # @return [GraphQL::Subscriptions]
-      attr_accessor :subscriptions
 
       # Returns the JSON response of {Introspection::INTROSPECTION_QUERY}.
       # @see {#as_json}
@@ -866,18 +266,29 @@ module GraphQL
       # @param context [Hash]
       # @param only [<#call(member, ctx)>]
       # @param except [<#call(member, ctx)>]
+      # @param include_deprecated_args [Boolean] If true, deprecated arguments will be included in the JSON response
+      # @param include_schema_description [Boolean] If true, the schema's description will be queried and included in the response
+      # @param include_is_repeatable [Boolean] If true, `isRepeatable: true|false` will be included with the schema's directives
+      # @param include_specified_by_url [Boolean] If true, scalar types' `specifiedByUrl:` will be included in the response
+      # @param include_is_one_of [Boolean] If true, `isOneOf: true|false` will be included with input objects
       # @return [Hash] GraphQL result
-      def as_json(only: nil, except: nil, context: {})
-        execute(Introspection.query(include_deprecated_args: true), only: only, except: except, context: context).to_h
+      def as_json(context: {}, include_deprecated_args: true, include_schema_description: false, include_is_repeatable: false, include_specified_by_url: false, include_is_one_of: false)
+        introspection_query = Introspection.query(
+          include_deprecated_args: include_deprecated_args,
+          include_schema_description: include_schema_description,
+          include_is_repeatable: include_is_repeatable,
+          include_is_one_of: include_is_one_of,
+          include_specified_by_url: include_specified_by_url,
+        )
+
+        execute(introspection_query, context: context).to_h
       end
 
       # Return the GraphQL IDL for the schema
       # @param context [Hash]
-      # @param only [<#call(member, ctx)>]
-      # @param except [<#call(member, ctx)>]
       # @return [String]
-      def to_definition(only: nil, except: nil, context: {})
-        GraphQL::Schema::Printer.print_schema(self, only: only, except: except, context: context)
+      def to_definition(context: {})
+        GraphQL::Schema::Printer.print_schema(self, context: context)
       end
 
       # Return the GraphQL::Language::Document IDL AST for the schema
@@ -886,6 +297,17 @@ module GraphQL
         GraphQL::Language::DocumentFromSchemaDefinition.new(self).document
       end
 
+      # @return [String, nil]
+      def description(new_description = nil)
+        if new_description
+          @description = new_description
+        elsif defined?(@description)
+          @description
+        else
+          find_inherited_value(:description, nil)
+        end
+      end
+
       def find(path)
         if !@finder
           @find_cache = {}
@@ -894,28 +316,15 @@ module GraphQL
         @find_cache[path] ||= @finder.find(path)
       end
 
-      def graphql_definition
-        @graphql_definition ||= to_graphql
-      end
-
-      def default_filter
-        GraphQL::Filter.new(except: default_mask)
-      end
-
-      def default_mask(new_mask = nil)
-        if new_mask
-          @own_default_mask = new_mask
-        else
-          @own_default_mask || find_inherited_value(:default_mask, Schema::NullMask)
-        end
-      end
-
       def static_validator
         GraphQL::StaticValidation::Validator.new(schema: self)
       end
 
+      # Add `plugin` to this schema
+      # @param plugin [#use] A Schema plugin
+      # @return void
       def use(plugin, **kwargs)
-        if kwargs.any?
+        if !kwargs.empty?
           plugin.use(self, **kwargs)
         else
           plugin.use(self)
@@ -927,84 +336,83 @@ module GraphQL
         find_inherited_value(:plugins, EMPTY_ARRAY) + own_plugins
       end
 
-      def to_graphql
-        schema_defn = self.new
-        schema_defn.raise_definition_error = true
-        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.max_complexity = max_complexity
-        schema_defn.error_bubbling = error_bubbling
-        schema_defn.max_depth = max_depth
-        schema_defn.default_max_page_size = default_max_page_size
-        schema_defn.orphan_types = orphan_types.map(&:graphql_definition)
-        schema_defn.disable_introspection_entry_points = disable_introspection_entry_points?
-        schema_defn.disable_schema_introspection_entry_point = disable_schema_introspection_entry_point?
-        schema_defn.disable_type_introspection_entry_point = disable_type_introspection_entry_point?
-
-        prepped_dirs = {}
-        directives.each { |k, v| prepped_dirs[k] = v.graphql_definition}
-        schema_defn.directives = prepped_dirs
-        schema_defn.introspection_namespace = introspection
-        schema_defn.resolve_type = method(:resolve_type)
-        schema_defn.object_from_id = method(:object_from_id)
-        schema_defn.id_from_object = method(:id_from_object)
-        schema_defn.type_error = method(:type_error)
-        schema_defn.context_class = context_class
-        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)
-        schema_defn.query_execution_strategy = query_execution_strategy
-        schema_defn.mutation_execution_strategy = mutation_execution_strategy
-        schema_defn.subscription_execution_strategy = subscription_execution_strategy
-        schema_defn.default_mask = default_mask
-        instrumenters.each do |step, insts|
-          insts.each do |inst|
-            schema_defn.instrumenters[step] << inst
-          end
-        end
-
-        lazy_methods.each do |lazy_class, value_method|
-          schema_defn.lazy_methods.set(lazy_class, value_method)
+      # 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)
+        if use_visibility_profile?
+          types = Visibility::Profile.from_context(context, self)
+          return types.all_types_h
         end
-
-        error_handler.each_rescue do |err_class, handler|
-          schema_defn.rescue_from(err_class, &handler)
+        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.new(
+                    duplicated_name: k, duplicated_definition_1: visible_t.inspect, duplicated_definition_2: t.inspect
+                  )
+                end
+              end
+            end
+            visible_t
+          else
+            v
+          end
         end
+        visible_types
+      end
 
-        schema_defn.subscriptions ||= self.subscriptions
-
-        if !schema_defn.interpreter?
-          schema_defn.instrumenters[:query] << GraphQL::Schema::Member::Instrumentation
+      # @param type_name [String]
+      # @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?)
+        if use_visibility_profile
+          return Visibility::Profile.from_context(context, self).type(type_name)
         end
-
-        if new_connections?
-          schema_defn.connections = self.connections
+        local_entry = own_types[type_name]
+        type_defn = case local_entry
+        when nil
+          nil
+        when Array
+          if context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Visibility::Profile)
+            local_entry
+          else
+            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.new(
+                    duplicated_name: type_name, duplicated_definition_1: visible_t.inspect, duplicated_definition_2: t.inspect
+                  )
+                end
+              end
+            end
+            visible_t
+          end
+        when Module
+          local_entry
+        else
+          raise "Invariant: unexpected own_types[#{type_name.inspect}]: #{local_entry.inspect}"
         end
 
-        schema_defn.send(:rebuild_artifacts)
-
-        schema_defn
+        type_defn ||
+          introspection_system.types[type_name] || # todo context-specific introspection?
+          (superclass.respond_to?(:get_type) ? superclass.get_type(type_name, context, use_visibility_profile) : nil)
       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
-        non_introspection_types.merge(introspection_system.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]
+      # @return [Boolean] Does this schema have _any_ definition for a type named `type_name`, regardless of visibility?
+      def has_defined_type?(type_name)
+        own_types.key?(type_name) || introspection_system.types.key?(type_name) || (superclass.respond_to?(:has_defined_type?) ? superclass.has_defined_type?(type_name) : false)
       end
 
       # @api private
@@ -1026,55 +434,127 @@ module GraphQL
         end
       end
 
-      def new_connections?
-        !!connections
-      end
-
-      def query(new_query_object = nil)
-        if new_query_object
+      # Get or set the root `query { ... }` object for this schema.
+      #
+      # @example Using `Types::Query` as the entry-point
+      #   query { Types::Query }
+      #
+      # @param new_query_object [Class<GraphQL::Schema::Object>] The root type to use for queries
+      # @param lazy_load_block If a block is given, then it will be called when GraphQL-Ruby needs the root query type.
+      # @return [Class<GraphQL::Schema::Object>, nil] The configured query root type, if there is one.
+      def query(new_query_object = nil, &lazy_load_block)
+        if new_query_object || block_given?
           if @query_object
-            raise GraphQL::Error, "Second definition of `query(...)` (#{new_query_object.inspect}) is invalid, already configured with #{@query_object.inspect}"
+            dup_defn = new_query_object || yield
+            raise GraphQL::Error, "Second definition of `query(...)` (#{dup_defn.inspect}) is invalid, already configured with #{@query_object.inspect}"
+          elsif use_visibility_profile?
+            if block_given?
+              if visibility.preload?
+                @query_object = lazy_load_block.call
+                self.visibility.query_configured(@query_object)
+              else
+                @query_object = lazy_load_block
+              end
+            else
+              @query_object = new_query_object
+              self.visibility.query_configured(@query_object)
+            end
           else
-            @query_object = new_query_object
-            add_type_and_traverse(new_query_object, root: true)
-            nil
+            @query_object = new_query_object || lazy_load_block.call
+            add_type_and_traverse(@query_object, root: true)
           end
+          nil
+        elsif @query_object.is_a?(Proc)
+          @query_object = @query_object.call
+          self.visibility&.query_configured(@query_object)
+          @query_object
         else
           @query_object || find_inherited_value(:query)
         end
       end
 
-      def mutation(new_mutation_object = nil)
-        if new_mutation_object
+      # Get or set the root `mutation { ... }` object for this schema.
+      #
+      # @example Using `Types::Mutation` as the entry-point
+      #   mutation { Types::Mutation }
+      #
+      # @param new_mutation_object [Class<GraphQL::Schema::Object>] The root type to use for mutations
+      # @param lazy_load_block If a block is given, then it will be called when GraphQL-Ruby needs the root mutation type.
+      # @return [Class<GraphQL::Schema::Object>, nil] The configured mutation root type, if there is one.
+      def mutation(new_mutation_object = nil, &lazy_load_block)
+        if new_mutation_object || block_given?
           if @mutation_object
-            raise GraphQL::Error, "Second definition of `mutation(...)` (#{new_mutation_object.inspect}) is invalid, already configured with #{@mutation_object.inspect}"
+            dup_defn = new_mutation_object || yield
+            raise GraphQL::Error, "Second definition of `mutation(...)` (#{dup_defn.inspect}) is invalid, already configured with #{@mutation_object.inspect}"
+          elsif use_visibility_profile?
+            if block_given?
+              if visibility.preload?
+                @mutation_object = lazy_load_block.call
+                self.visibility.mutation_configured(@mutation_object)
+              else
+                @mutation_object = lazy_load_block
+              end
+            else
+              @mutation_object = new_mutation_object
+              self.visibility.mutation_configured(@mutation_object)
+            end
           else
-            @mutation_object = new_mutation_object
-            add_type_and_traverse(new_mutation_object, root: true)
-            nil
+            @mutation_object = new_mutation_object || lazy_load_block.call
+            add_type_and_traverse(@mutation_object, root: true)
           end
+          nil
+        elsif @mutation_object.is_a?(Proc)
+          @mutation_object = @mutation_object.call
+          self.visibility&.mutation_configured(@mutation_object)
+          @mutation_object
         else
           @mutation_object || find_inherited_value(:mutation)
         end
       end
 
-      def subscription(new_subscription_object = nil)
-        if new_subscription_object
+      # Get or set the root `subscription { ... }` object for this schema.
+      #
+      # @example Using `Types::Subscription` as the entry-point
+      #   subscription { Types::Subscription }
+      #
+      # @param new_subscription_object [Class<GraphQL::Schema::Object>] The root type to use for subscriptions
+      # @param lazy_load_block If a block is given, then it will be called when GraphQL-Ruby needs the root subscription type.
+      # @return [Class<GraphQL::Schema::Object>, nil] The configured subscription root type, if there is one.
+      def subscription(new_subscription_object = nil, &lazy_load_block)
+        if new_subscription_object || block_given?
           if @subscription_object
-            raise GraphQL::Error, "Second definition of `subscription(...)` (#{new_subscription_object.inspect}) is invalid, already configured with #{@subscription_object.inspect}"
+            dup_defn = new_subscription_object || yield
+            raise GraphQL::Error, "Second definition of `subscription(...)` (#{dup_defn.inspect}) is invalid, already configured with #{@subscription_object.inspect}"
+          elsif use_visibility_profile?
+            if block_given?
+              if visibility.preload?
+                @subscription_object = lazy_load_block.call
+                visibility.subscription_configured(@subscription_object)
+              else
+                @subscription_object = lazy_load_block
+              end
+            else
+              @subscription_object = new_subscription_object
+              self.visibility.subscription_configured(@subscription_object)
+            end
+            add_subscription_extension_if_necessary
           else
-            @subscription_object = new_subscription_object
+            @subscription_object = new_subscription_object || lazy_load_block.call
             add_subscription_extension_if_necessary
-            add_type_and_traverse(new_subscription_object, root: true)
-            nil
+            add_type_and_traverse(@subscription_object, root: true)
           end
+          nil
+        elsif @subscription_object.is_a?(Proc)
+          @subscription_object = @subscription_object.call
+          add_subscription_extension_if_necessary
+          self.visibility.subscription_configured(@subscription_object)
+          @subscription_object
         else
           @subscription_object || find_inherited_value(:subscription)
         end
       end
 
-      # @see [GraphQL::Schema::Warden] Resticted access to root types
-      # @return [GraphQL::ObjectType, nil]
+      # @api private
       def root_type_for_operation(operation)
         case operation
         when "query"
@@ -1084,38 +564,90 @@ module GraphQL
         when "subscription"
           subscription
         else
-          raise ArgumentError, "unknown operation type: #{operation}"
+          raise ArgumentError, "unknown operation type: #{operation}"
+        end
+      end
+
+      # @return [Array<Class>] The root types (query, mutation, subscription) defined for this schema
+      def root_types
+        if use_visibility_profile?
+          [query, mutation, subscription].compact
+        else
+          @root_types
+        end
+      end
+
+      # @api private
+      def warden_class
+        if defined?(@warden_class)
+          @warden_class
+        elsif superclass.respond_to?(:warden_class)
+          superclass.warden_class
+        else
+          GraphQL::Schema::Warden
+        end
+      end
+
+      # @api private
+      attr_writer :warden_class
+
+      # @api private
+      def visibility_profile_class
+        if defined?(@visibility_profile_class)
+          @visibility_profile_class
+        elsif superclass.respond_to?(:visibility_profile_class)
+          superclass.visibility_profile_class
+        else
+          GraphQL::Schema::Visibility::Profile
+        end
+      end
+
+      # @api private
+      attr_writer :visibility_profile_class, :use_visibility_profile
+      # @api private
+      attr_accessor :visibility
+      # @api private
+      def use_visibility_profile?
+        if defined?(@use_visibility_profile)
+          @use_visibility_profile
+        elsif superclass.respond_to?(:use_visibility_profile?)
+          superclass.use_visibility_profile?
+        else
+          false
         end
       end
 
-      def root_types
-        @root_types
-      end
-
       # @param type [Module] The type definition whose possible types you want to see
+      # @param context [GraphQL::Query::Context] used for filtering visible possible types at runtime
+      # @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)
+      def possible_types(type = nil, context = GraphQL::Query::NullContext.instance, use_visibility_profile = use_visibility_profile?)
+        if use_visibility_profile
+          if type
+            return Visibility::Profile.from_context(context, self).possible_types(type)
+          else
+            raise "Schema.possible_types is not implemented for `use_visibility_profile?`"
+          end
+        end
         if type
           # TODO duck-typing `.possible_types` would probably be nicer here
           if type.kind.union?
             type.possible_types(context: context)
           else
-            stored_possible_types = own_possible_types[type.graphql_name]
+            stored_possible_types = own_possible_types[type]
             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 }
+                possible_type.interfaces(context).include?(type)
               end
             else
               stored_possible_types
             end
             visible_possible_types ||
-              introspection_system.possible_types[type.graphql_name] ||
+              introspection_system.possible_types[type] ||
               (
                 superclass.respond_to?(:possible_types) ?
-                  superclass.possible_types(type, context) :
+                  superclass.possible_types(type, context, use_visibility_profile) :
                   EMPTY_ARRAY
               )
           end
@@ -1150,50 +682,43 @@ module GraphQL
       attr_writer :dataloader_class
 
       def references_to(to_type = nil, from: nil)
-        @own_references_to ||= Hash.new { |h, k| h[k] = [] }
         if to_type
-          if !to_type.is_a?(String)
-            to_type = to_type.graphql_name
-          end
-
           if from
-            @own_references_to[to_type] << from
+            refs = own_references_to[to_type] ||= []
+            refs << from
           else
-            own_refs = @own_references_to[to_type]
-            inherited_refs = find_inherited_value(:references_to, EMPTY_HASH)[to_type] || EMPTY_ARRAY
-            own_refs + inherited_refs
+            get_references_to(to_type) || EMPTY_ARRAY
           end
         else
           # `@own_references_to` can be quite large for big schemas,
           # and generally speaking, we won't inherit any values.
           # So optimize the most common case -- don't create a duplicate Hash.
           inherited_value = find_inherited_value(:references_to, EMPTY_HASH)
-          if inherited_value.any?
-            inherited_value.merge(@own_references_to)
+          if !inherited_value.empty?
+            inherited_value.merge(own_references_to)
           else
-            @own_references_to
+            own_references_to
           end
         end
       end
 
-      def type_from_ast(ast_node, context: nil)
-        type_owner = context ? context.warden : self
-        GraphQL::Schema::TypeExpression.build_type(type_owner, ast_node)
+      def type_from_ast(ast_node, context: self.query_class.new(self, "{ __typename }").context)
+        GraphQL::Schema::TypeExpression.build_type(context.query.types, ast_node)
       end
 
-      def get_field(type_or_name, field_name)
+      def get_field(type_or_name, field_name, context = GraphQL::Query::NullContext.instance)
         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})"
+          raise GraphQL::InvariantError, "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
@@ -1204,24 +729,31 @@ module GraphQL
         end
       end
 
-      def get_fields(type)
-        type.fields
+      def get_fields(type, context = GraphQL::Query::NullContext.instance)
+        type.fields(context)
       end
 
+      # Pass a custom introspection module here to use it for this schema.
+      # @param new_introspection_namespace [Module] If given, use this module for custom introspection on the schema
+      # @return [Module, nil] The configured namespace, if there is one
       def introspection(new_introspection_namespace = nil)
         if new_introspection_namespace
           @introspection = new_introspection_namespace
           # reset this cached value:
           @introspection_system = nil
+          introspection_system
+          @introspection
         else
           @introspection || find_inherited_value(:introspection)
         end
       end
 
+      # @return [Schema::IntrospectionSystem] Based on {introspection}
       def introspection_system
         if !@introspection_system
           @introspection_system = Schema::IntrospectionSystem.new(self)
           @introspection_system.resolve_late_bindings
+          self.visibility&.introspection_system_configured(@introspection_system)
         end
         @introspection_system
       end
@@ -1241,27 +773,58 @@ module GraphQL
         end
       end
 
-      def query_execution_strategy(new_query_execution_strategy = nil)
+      # A limit on the number of tokens to accept on incoming query strings.
+      # Use this to prevent parsing maliciously-large query strings.
+      # @return [nil, Integer]
+      def max_query_string_tokens(new_max_tokens = NOT_CONFIGURED)
+        if NOT_CONFIGURED.equal?(new_max_tokens)
+          defined?(@max_query_string_tokens) ? @max_query_string_tokens : find_inherited_value(:max_query_string_tokens)
+        else
+          @max_query_string_tokens = new_max_tokens
+        end
+      end
+
+      def default_page_size(new_default_page_size = nil)
+        if new_default_page_size
+          @default_page_size = new_default_page_size
+        else
+          @default_page_size || find_inherited_value(:default_page_size)
+        end
+      end
+
+      def query_execution_strategy(new_query_execution_strategy = nil, deprecation_warning: true)
+        if deprecation_warning
+          warn "GraphQL::Schema.query_execution_strategy is deprecated without replacement. Use `GraphQL::Query.new` directly to create and execute a custom query instead."
+          warn "  #{caller(1, 1).first}"
+        end
         if new_query_execution_strategy
           @query_execution_strategy = new_query_execution_strategy
         else
-          @query_execution_strategy || find_inherited_value(:query_execution_strategy, self.default_execution_strategy)
+          @query_execution_strategy || (superclass.respond_to?(:query_execution_strategy) ? superclass.query_execution_strategy(deprecation_warning: false) : self.default_execution_strategy)
         end
       end
 
-      def mutation_execution_strategy(new_mutation_execution_strategy = nil)
+      def mutation_execution_strategy(new_mutation_execution_strategy = nil, deprecation_warning: true)
+        if deprecation_warning
+          warn "GraphQL::Schema.mutation_execution_strategy is deprecated without replacement. Use `GraphQL::Query.new` directly to create and execute a custom query instead."
+            warn "  #{caller(1, 1).first}"
+        end
         if new_mutation_execution_strategy
           @mutation_execution_strategy = new_mutation_execution_strategy
         else
-          @mutation_execution_strategy || find_inherited_value(:mutation_execution_strategy, self.default_execution_strategy)
+          @mutation_execution_strategy || (superclass.respond_to?(:mutation_execution_strategy) ? superclass.mutation_execution_strategy(deprecation_warning: false) : self.default_execution_strategy)
         end
       end
 
-      def subscription_execution_strategy(new_subscription_execution_strategy = nil)
+      def subscription_execution_strategy(new_subscription_execution_strategy = nil, deprecation_warning: true)
+        if deprecation_warning
+          warn "GraphQL::Schema.subscription_execution_strategy is deprecated without replacement. Use `GraphQL::Query.new` directly to create and execute a custom query instead."
+          warn "  #{caller(1, 1).first}"
+        end
         if new_subscription_execution_strategy
           @subscription_execution_strategy = new_subscription_execution_strategy
         else
-          @subscription_execution_strategy || find_inherited_value(:subscription_execution_strategy, self.default_execution_strategy)
+          @subscription_execution_strategy || (superclass.respond_to?(:subscription_execution_strategy) ? superclass.subscription_execution_strategy(deprecation_warning: false) : self.default_execution_strategy)
         end
       end
 
@@ -1286,19 +849,39 @@ module GraphQL
         else
           string_or_document
         end
-        query = GraphQL::Query.new(self, document: doc, context: context)
+        query = query_class.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)
+        res = validator.validate(query, timeout: validate_timeout, max_errors: validate_max_errors)
         res[:errors]
       end
 
+      # @param new_query_class [Class<GraphQL::Query>] A subclass to use when executing queries
+      def query_class(new_query_class = NOT_CONFIGURED)
+        if NOT_CONFIGURED.equal?(new_query_class)
+          @query_class || (superclass.respond_to?(:query_class) ? superclass.query_class : GraphQL::Query)
+        else
+          @query_class = new_query_class
+        end
+      end
+
+      attr_writer :validate_max_errors
+
+      def validate_max_errors(new_validate_max_errors = NOT_CONFIGURED)
+        if NOT_CONFIGURED.equal?(new_validate_max_errors)
+          defined?(@validate_max_errors) ? @validate_max_errors : find_inherited_value(:validate_max_errors)
+        else
+          @validate_max_errors = new_validate_max_errors
+        end
+      end
+
       attr_writer :max_complexity
 
-      def max_complexity(max_complexity = nil)
+      def max_complexity(max_complexity = nil, count_introspection_fields: true)
         if max_complexity
           @max_complexity = max_complexity
+          @max_complexity_count_introspection_fields = count_introspection_fields
         elsif defined?(@max_complexity)
           @max_complexity
         else
@@ -1306,26 +889,23 @@ module GraphQL
         end
       end
 
+      def max_complexity_count_introspection_fields
+        if defined?(@max_complexity_count_introspection_fields)
+          @max_complexity_count_introspection_fields
+        else
+          find_inherited_value(:max_complexity_count_introspection_fields, true)
+        end
+      end
+
       attr_writer :analysis_engine
 
       def analysis_engine
         @analysis_engine || find_inherited_value(:analysis_engine, self.default_analysis_engine)
       end
 
-      def using_ast_analysis?
-        analysis_engine == GraphQL::Analysis::AST
-      end
-
-      def interpreter?
-        query_execution_strategy == GraphQL::Execution::Interpreter &&
-          mutation_execution_strategy == GraphQL::Execution::Interpreter &&
-          subscription_execution_strategy == GraphQL::Execution::Interpreter
-      end
-
-      attr_writer :interpreter
-
       def error_bubbling(new_error_bubbling = nil)
         if !new_error_bubbling.nil?
+          warn("error_bubbling(#{new_error_bubbling.inspect}) is deprecated; the default value of `false` will be the only option in GraphQL-Ruby 3.0")
           @error_bubbling = new_error_bubbling
         else
           @error_bubbling.nil? ? find_inherited_value(:error_bubbling) : @error_bubbling
@@ -1336,9 +916,10 @@ module GraphQL
 
       attr_writer :max_depth
 
-      def max_depth(new_max_depth = nil)
+      def max_depth(new_max_depth = nil, count_introspection_fields: true)
         if new_max_depth
           @max_depth = new_max_depth
+          @count_introspection_fields = count_introspection_fields
         elsif defined?(@max_depth)
           @max_depth
         else
@@ -1346,6 +927,14 @@ module GraphQL
         end
       end
 
+      def count_introspection_fields
+        if defined?(@count_introspection_fields)
+          @count_introspection_fields
+        else
+          find_inherited_value(:count_introspection_fields, true)
+        end
+      end
+
       def disable_introspection_entry_points
         @disable_introspection_entry_points = true
         # TODO: this clears the cache made in `def types`. But this is not a great solution.
@@ -1388,15 +977,62 @@ module GraphQL
         end
       end
 
+      # @param new_extra_types [Module] Type definitions to include in printing and introspection, even though they aren't referenced in the schema
+      # @return [Array<Module>] Type definitions added to this schema
+      def extra_types(*new_extra_types)
+        if !new_extra_types.empty?
+          new_extra_types = new_extra_types.flatten
+          @own_extra_types ||= []
+          @own_extra_types.concat(new_extra_types)
+        end
+        inherited_et = find_inherited_value(:extra_types, nil)
+        if inherited_et
+          if @own_extra_types
+            inherited_et + @own_extra_types
+          else
+            inherited_et
+          end
+        else
+          @own_extra_types || EMPTY_ARRAY
+        end
+      end
+
+      # Tell the schema about these types so that they can be registered as implementations of interfaces in the schema.
+      #
+      # This method must be used when an object type is connected to the schema as an interface implementor but
+      # not as a return type of a field. In that case, if the object type isn't registered here, GraphQL-Ruby won't be able to find it.
+      #
+      # @param new_orphan_types [Array<Class<GraphQL::Schema::Object>>] Object types to register as implementations of interfaces in the schema.
+      # @return [Array<Class<GraphQL::Schema::Object>>] All previously-registered orphan types for this schema
       def orphan_types(*new_orphan_types)
-        if new_orphan_types.any?
+        if !new_orphan_types.empty?
           new_orphan_types = new_orphan_types.flatten
-          add_type_and_traverse(new_orphan_types, root: false)
-          @orphan_types = new_orphan_types
+          non_object_types = new_orphan_types.reject { |ot| ot.is_a?(Class) && ot < GraphQL::Schema::Object }
+          if !non_object_types.empty?
+            raise ArgumentError, <<~ERR
+              Only object type classes should be added as `orphan_types(...)`.
+
+              - Remove these no-op types from `orphan_types`: #{non_object_types.map { |t| "#{t.inspect} (#{t.kind.name})"}.join(", ")}
+              - See https://graphql-ruby.org/type_definitions/interfaces.html#orphan-types
+
+              To add other types to your schema, you might want `extra_types`: https://graphql-ruby.org/schema/definition.html#extra-types
+            ERR
+          end
+          add_type_and_traverse(new_orphan_types, root: false) unless use_visibility_profile?
           own_orphan_types.concat(new_orphan_types.flatten)
+          self.visibility&.orphan_types_configured(new_orphan_types)
         end
 
-        find_inherited_value(:orphan_types, EMPTY_ARRAY) + own_orphan_types
+        inherited_ot = find_inherited_value(:orphan_types, nil)
+        if inherited_ot
+          if !own_orphan_types.empty?
+            inherited_ot + own_orphan_types
+          else
+            inherited_ot
+          end
+        else
+          own_orphan_types
+        end
       end
 
       def default_execution_strategy
@@ -1415,6 +1051,29 @@ module GraphQL
         end
       end
 
+
+      # @param new_default_logger [#log] Something to use for logging messages
+      def default_logger(new_default_logger = NOT_CONFIGURED)
+        if NOT_CONFIGURED.equal?(new_default_logger)
+          if defined?(@default_logger)
+            @default_logger
+          elsif superclass.respond_to?(:default_logger)
+            superclass.default_logger
+          elsif defined?(Rails) && Rails.respond_to?(:logger) && (rails_logger = Rails.logger)
+            rails_logger
+          else
+            def_logger = Logger.new($stdout)
+            def_logger.info! # It doesn't output debug info by default
+            def_logger
+          end
+        elsif new_default_logger == nil
+          @default_logger = Logger.new(IO::NULL)
+        else
+          @default_logger = new_default_logger
+        end
+      end
+
+      # @param new_context_class [Class<GraphQL::Query::Context>] A subclass to use when executing queries
       def context_class(new_context_class = nil)
         if new_context_class
           @context_class = new_context_class
@@ -1423,28 +1082,79 @@ module GraphQL
         end
       end
 
+      # Register a handler for errors raised during execution. The handlers can return a new value or raise a new error.
+      #
+      # @example Handling "not found" with a client-facing error
+      #   rescue_from(ActiveRecord::NotFound) { raise GraphQL::ExecutionError, "An object could not be found" }
+      #
+      # @param err_classes [Array<StandardError>] Classes which should be rescued by `handler_block`
+      # @param handler_block The code to run when one of those errors is raised during execution
+      # @yieldparam error [StandardError] An instance of one of the configured `err_classes`
+      # @yieldparam object [Object] The current application object in the query when the error was raised
+      # @yieldparam arguments [GraphQL::Query::Arguments] The current field arguments when the error was raised
+      # @yieldparam context [GraphQL::Query::Context] The context for the currently-running operation
+      # @yieldreturn [Object] Some object to use in the place where this error was raised
+      # @raise [GraphQL::ExecutionError] In the handler, raise to add a client-facing error to the response
+      # @raise [StandardError] In the handler, raise to crash the query with a developer-facing error
       def rescue_from(*err_classes, &handler_block)
         err_classes.each do |err_class|
-          error_handler.rescue_from(err_class, handler_block)
+          Execution::Errors.register_rescue_from(err_class, error_handlers[:subclass_handlers], handler_block)
+        end
+      end
+
+      NEW_HANDLER_HASH = ->(h, k) {
+        h[k] = {
+          class: k,
+          handler: nil,
+          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
+         }
+      }
+
+      def error_handlers
+        @error_handlers ||= {
+          class: nil,
+          handler: nil,
+          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
+        }
+      end
+
+      # @api private
+      def handle_or_reraise(context, err)
+        handler = Execution::Errors.find_handler_for(self, err.class)
+        if handler
+          obj = context[:current_object]
+          args = context[:current_arguments]
+          args = args && args.respond_to?(:keyword_arguments) ? args.keyword_arguments : nil
+          field = context[:current_field]
+          if obj.is_a?(GraphQL::Schema::Object)
+            obj = obj.object
+          end
+          handler[:handler].call(err, obj, args, context, field)
+        else
+          raise err
         end
       end
 
       # rubocop:disable Lint/DuplicateMethods
       module ResolveTypeWithType
         def resolve_type(type, obj, ctx)
-          first_resolved_type, resolved_value = if type.is_a?(Module) && type.respond_to?(:resolve_type)
+          maybe_lazy_resolve_type_result = if type.is_a?(Module) && type.respond_to?(:resolve_type)
             type.resolve_type(obj, ctx)
           else
             super
           end
 
-          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)
-              if resolved_value
-                [resolved_type, resolved_value]
-              else
-                resolved_type
-              end
+          after_lazy(maybe_lazy_resolve_type_result) do |resolve_type_result|
+            if resolve_type_result.is_a?(Array) && resolve_type_result.size == 2
+              resolved_type = resolve_type_result[0]
+              resolved_value = resolve_type_result[1]
+            else
+              resolved_type = resolve_type_result
+              resolved_value = obj
+            end
+
+            if resolved_type.nil? || (resolved_type.is_a?(Module) && resolved_type.respond_to?(:kind))
+              [resolved_type, resolved_value]
             else
               raise ".resolve_type should return a type definition, but got #{resolved_type.inspect} (#{resolved_type.class}) from `resolve_type(#{type}, #{obj}, #{ctx})`"
             end
@@ -1452,51 +1162,96 @@ module GraphQL
         end
       end
 
-      def resolve_type(type, obj, ctx)
-        if type.kind.object?
-          type
-        else
-          raise GraphQL::RequiredImplementationMissingError, "#{self.name}.resolve_type(type, obj, ctx) must be implemented to use Union types or Interface types (tried to resolve: #{type.name})"
-        end
+      # GraphQL-Ruby calls this method during execution when it needs the application to determine the type to use for an object.
+      #
+      # Usually, this object was returned from a field whose return type is an {GraphQL::Schema::Interface} or a {GraphQL::Schema::Union}.
+      # But this method is called in other cases, too -- for example, when {GraphQL::Schema::Argument.loads} cases an object to be directly loaded from the database.
+      #
+      # @example Returning a GraphQL type based on the object's class name
+      #   class MySchema < GraphQL::Schema
+      #     def resolve_type(_abs_type, object, _context)
+      #       graphql_type_name = "Types::#{object.class.name}Type"
+      #       graphql_type_name.constantize # If this raises a NameError, then come implement special cases in this method
+      #     end
+      #   end
+      # @param abstract_type [Class, Module, nil] The Interface or Union type which is being resolved, if there is one
+      # @param application_object [Object] The object returned from a field whose type must be determined
+      # @param context [GraphQL::Query::Context] The query context for the currently-executing query
+      # @return [Class<GraphQL::Schema::Object] The Object type definition to use for `obj`
+      def resolve_type(abstract_type, application_object, context)
+        raise GraphQL::RequiredImplementationMissingError, "#{self.name}.resolve_type(abstract_type, application_object, context) must be implemented to use Union types, Interface types, or `loads:` (tried to resolve: #{abstract_type.name})"
       end
       # rubocop:enable Lint/DuplicateMethods
 
       def inherited(child_class)
         if self == GraphQL::Schema
           child_class.directives(default_directives.values)
+          child_class.extend(SubclassGetReferencesTo)
+        end
+        # Make sure the child class has these built out, so that
+        # subclasses can be modified by later calls to `trace_with`
+        own_trace_modes.each do |name, _class|
+          child_class.own_trace_modes[name] = child_class.build_trace_mode(name)
         end
         child_class.singleton_class.prepend(ResolveTypeWithType)
-        super
-      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}`)"
+        if use_visibility_profile?
+          vis = self.visibility
+          child_class.visibility = vis.dup_for(child_class)
+        end
+        super
       end
 
-      def id_from_object(object, type, ctx)
-        raise GraphQL::RequiredImplementationMissingError, "#{self.name}.id_from_object(object, type, ctx) must be implemented to create global ids (tried to create an id for `#{object.inspect}`)"
+      # Fetch an object based on an incoming ID and the current context. This method should return an object
+      # from your application, or return `nil` if there is no object or the object shouldn't be available to this operation.
+      #
+      # @example Fetching an object with Rails's GlobalID
+      #   def self.object_from_id(object_id, _context)
+      #     GlobalID.find(global_id)
+      #     # TODO: use `context[:current_user]` to determine if this object is authorized.
+      #   end
+      # @param object_id [String] The ID to fetch an object for. This may be client-provided (as in `node(id: ...)` or `loads:`) or previously stored by the schema (eg, by the `ObjectCache`)
+      # @param context [GraphQL::Query::Context] The context for the currently-executing operation
+      # @return [Object, nil] The application which `object_id` references, or `nil` if there is no object or the current operation shouldn't have access to the object
+      # @see id_from_object which produces these IDs
+      def object_from_id(object_id, context)
+        raise GraphQL::RequiredImplementationMissingError, "#{self.name}.object_from_id(object_id, context) must be implemented to load by ID (tried to load from id `#{object_id}`)"
+      end
+
+      # Return a stable ID string for `object` so that it can be refetched later, using {.object_from_id}.
+      #
+      # {GlobalID}(https://github.com/rails/globalid) and {SQIDs}(https://sqids.org/ruby) can both be used to create IDs.
+      #
+      # @example Using Rails's GlobalID to generate IDs
+      #   def self.id_from_object(application_object, graphql_type, context)
+      #     application_object.to_gid_param
+      #   end
+      #
+      # @param application_object [Object] Some object encountered by GraphQL-Ruby while running a query
+      # @param graphql_type [Class, Module] The type that GraphQL-Ruby is using for `application_object` during this query
+      # @param context [GraphQL::Query::Context] The context for the operation that is currently running
+      # @return [String] A stable identifier which can be passed to {.object_from_id} later to re-fetch `application_object`
+      def id_from_object(application_object, graphql_type, context)
+        raise GraphQL::RequiredImplementationMissingError, "#{self.name}.id_from_object(application_object, graphql_type, context) must be implemented to create global ids (tried to create an id for `#{application_object.inspect}`)"
       end
 
       def visible?(member, ctx)
-        member.type_class.visible?(ctx)
+        member.visible?(ctx)
       end
 
-      def accessible?(member, ctx)
-        member.type_class.accessible?(ctx)
+      def schema_directive(dir_class, **options)
+        @own_schema_directives ||= []
+        Member::HasDirectives.add_directive(self, @own_schema_directives, dir_class, options)
       end
 
-      # This hook is called when a client tries to access one or more
-      # fields that fail the `accessible?` check.
-      #
-      # By default, an error is added to the response. Override this hook to
-      # track metrics or return a different error to the client.
-      #
-      # @param error [InaccessibleFieldsError] The analysis error for this check
-      # @return [AnalysisError, nil] Return an error to skip the query
-      def inaccessible_fields(error)
-        error
+      def schema_directives
+        Member::HasDirectives.get_directives(self, @own_schema_directives, :schema_directives)
       end
 
+      # Called when a type is needed by name at runtime
+      def load_type(type_name, ctx)
+        get_type(type_name, ctx)
+      end
       # This hook is called when an object fails an `authorized?` check.
       # You might report to your bug tracker here, so you can correct
       # the field resolvers not to return unauthorized objects.
@@ -1532,58 +1287,75 @@ module GraphQL
         unauthorized_object(unauthorized_error)
       end
 
-      def type_error(type_err, ctx)
-        DefaultTypeError.call(type_err, ctx)
+      # Called at runtime when GraphQL-Ruby encounters a mismatch between the application behavior
+      # and the GraphQL type system.
+      #
+      # The default implementation of this method is to follow the GraphQL specification,
+      # but you can override this to report errors to your bug tracker or customize error handling.
+      # @param type_error [GraphQL::Error] several specific error classes are passed here, see the default implementation for details
+      # @param context [GraphQL::Query::Context] the context for the currently-running operation
+      # @return [void]
+      # @raise [GraphQL::ExecutionError] to return this error to the client
+      # @raise [GraphQL::Error] to crash the query and raise a developer-facing error
+      def type_error(type_error, ctx)
+        case type_error
+        when GraphQL::InvalidNullError
+          ctx.errors << type_error
+        when GraphQL::UnresolvedTypeError, GraphQL::StringEncodingError, GraphQL::IntegerEncodingError
+          raise type_error
+        when GraphQL::IntegerDecodingError
+          nil
+        end
       end
 
       # A function to call when {#execute} receives an invalid query string
       #
       # The default is to add the error to `context.errors`
-      # @param err [GraphQL::ParseError] The error encountered during parsing
+      # @param parse_err [GraphQL::ParseError] The error encountered during parsing
       # @param ctx [GraphQL::Query::Context] The context for the query where the error occurred
       # @return void
       def parse_error(parse_err, ctx)
         ctx.errors.push(parse_err)
       end
 
-      # @return [GraphQL::Execution::Errors]
-      def error_handler
-        @error_handler ||= GraphQL::Execution::Errors.new(self)
-      end
-
       def lazy_resolve(lazy_class, value_method)
         lazy_methods.set(lazy_class, value_method)
       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
-          instrument_step
-        end
+        warn <<~WARN
+        Schema.instrument is deprecated, use `trace_with` instead: https://graphql-ruby.org/queries/tracing.html"
+          (From `#{self}.instrument(#{instrument_step}, #{instrumenter})` at #{caller(1, 1).first})
 
-        own_instrumenters[step] << instrumenter
+        WARN
+        trace_with(Tracing::LegacyHooksTrace)
+        own_instrumenters[instrument_step] << instrumenter
       end
 
       # Add several directives at once
       # @param new_directives [Class]
       def directives(*new_directives)
-        if new_directives.any?
+        if !new_directives.empty?
           new_directives.flatten.each { |d| directive(d) }
         end
 
-        find_inherited_value(:directives, default_directives).merge(own_directives)
+        inherited_dirs = find_inherited_value(:directives, default_directives)
+        if !own_directives.empty?
+          inherited_dirs.merge(own_directives)
+        else
+          inherited_dirs
+        end
       end
 
       # 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)
+        if use_visibility_profile?
+          own_directives[new_directive.graphql_name] = new_directive
+        else
+          add_type_and_traverse(new_directive, root: false)
+        end
       end
 
       def default_directives
@@ -1591,10 +1363,21 @@ module GraphQL
           "include" => GraphQL::Schema::Directive::Include,
           "skip" => GraphQL::Schema::Directive::Skip,
           "deprecated" => GraphQL::Schema::Directive::Deprecated,
+          "oneOf" => GraphQL::Schema::Directive::OneOf,
+          "specifiedBy" => GraphQL::Schema::Directive::SpecifiedBy,
         }.freeze
       end
 
-      def tracer(new_tracer)
+      def tracer(new_tracer, silence_deprecation_warning: false)
+        if !silence_deprecation_warning
+          warn("`Schema.tracer(#{new_tracer.inspect})` is deprecated; use module-based `trace_with` instead. See: https://graphql-ruby.org/queries/tracing.html")
+          warn "  #{caller(1, 1).first}"
+        end
+        default_trace = trace_class_for(:default, build: true)
+        if default_trace.nil? || !(default_trace < GraphQL::Tracing::CallLegacyTracers)
+          trace_with(GraphQL::Tracing::CallLegacyTracers)
+        end
+
         own_tracers << new_tracer
       end
 
@@ -1602,27 +1385,103 @@ module GraphQL
         find_inherited_value(:tracers, EMPTY_ARRAY) + own_tracers
       end
 
-      def query_analyzer(new_analyzer)
-        if new_analyzer == GraphQL::Authorization::Analyzer
-          GraphQL::Deprecation.warn("The Authorization query analyzer is deprecated. Authorizing at query runtime is generally a better idea.")
+      # Mix `trace_mod` into this schema's `Trace` class so that its methods
+      # will be called at runtime.
+      #
+      # @param trace_mod [Module] A module that implements tracing methods
+      # @param mode [Symbol] Trace module will only be used for this trade mode
+      # @param options [Hash] Keywords that will be passed to the tracing class during `#initialize`
+      # @return [void]
+      # @see GraphQL::Tracing::Trace for available tracing methods
+      def trace_with(trace_mod, mode: :default, **options)
+        if mode.is_a?(Array)
+          mode.each { |m| trace_with(trace_mod, mode: m, **options) }
+        else
+          tc = own_trace_modes[mode] ||= build_trace_mode(mode)
+          tc.include(trace_mod)
+          own_trace_modules[mode] << trace_mod
+          add_trace_options_for(mode, options)
+          if mode == :default
+            # This module is being added as a default tracer. If any other mode classes
+            # have already been created, but get their default behavior from a superclass,
+            # Then mix this into this schema's subclass.
+            # (But don't mix it into mode classes that aren't default-based.)
+            own_trace_modes.each do |other_mode_name, other_mode_class|
+              if other_mode_class < DefaultTraceClass
+                # Don't add it back to the inheritance tree if it's already there
+                if !(other_mode_class < trace_mod)
+                  other_mode_class.include(trace_mod)
+                end
+                # Add any options so they'll be available
+                add_trace_options_for(other_mode_name, options)
+              end
+            end
+          end
         end
-        own_query_analyzers << new_analyzer
+        nil
       end
 
-      def query_analyzers
-        find_inherited_value(:query_analyzers, EMPTY_ARRAY) + own_query_analyzers
+      # The options hash for this trace mode
+      # @return [Hash]
+      def trace_options_for(mode)
+        @trace_options_for_mode ||= {}
+        @trace_options_for_mode[mode] ||= begin
+          # It may be time to create an options hash for a mode that wasn't registered yet.
+          # Mix in the default options in that case.
+          default_options = mode == :default ? EMPTY_HASH : trace_options_for(:default)
+          # Make sure this returns a new object so that other hashes aren't modified later
+          if superclass.respond_to?(:trace_options_for)
+            superclass.trace_options_for(mode).merge(default_options)
+          else
+            default_options.dup
+          end
+        end
       end
 
-      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
+      # Create a trace instance which will include the trace modules specified for the optional mode.
+      #
+      # If no `mode:` is given, then {default_trace_mode} will be used.
+      #
+      # @param mode [Symbol] Trace modules for this trade mode will be included
+      # @param options [Hash] Keywords that will be passed to the tracing class during `#initialize`
+      # @return [Tracing::Trace]
+      def new_trace(mode: nil, **options)
+        target = options[:query] || options[:multiplex]
+        mode ||= target && target.context[:trace_mode]
+
+        trace_mode = if mode
+          mode
+        elsif target && target.context[:backtrace]
+          if default_trace_mode != :default
+            raise ArgumentError, "Can't use `context[:backtrace]` with a custom default trace mode (`#{dm.inspect}`)"
+          else
+            own_trace_modes[:default_backtrace] ||= build_trace_mode(:default_backtrace)
+            options_trace_mode = :default
+            :default_backtrace
+          end
         else
-          # TODO make sure this is cached when running a query
-          MiddlewareChain.new(steps: all_middleware, final_step: GraphQL::Execution::Execute::FieldResolveStep)
+          default_trace_mode
         end
+
+        options_trace_mode ||= trace_mode
+        base_trace_options = trace_options_for(options_trace_mode)
+        trace_options = base_trace_options.merge(options)
+        trace_class_for_mode = trace_class_for(trace_mode, build: true)
+        trace_class_for_mode.new(**trace_options)
+      end
+
+      # @param new_analyzer [Class<GraphQL::Analysis::Analyzer>] An analyzer to run on queries to this schema
+      # @see GraphQL::Analysis the analysis system
+      def query_analyzer(new_analyzer)
+        own_query_analyzers << new_analyzer
+      end
+
+      def query_analyzers
+        find_inherited_value(:query_analyzers, EMPTY_ARRAY) + own_query_analyzers
       end
 
+      # @param new_analyzer [Class<GraphQL::Analysis::Analyzer>] An analyzer to run on multiplexes to this schema
+      # @see GraphQL::Analysis the analysis system
       def multiplex_analyzer(new_analyzer)
         own_multiplex_analyzers << new_analyzer
       end
@@ -1631,9 +1490,17 @@ 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
+      # @return [GraphQL::Query::Result] query result, ready to be serialized as JSON
       def execute(query_str = nil, **kwargs)
         if query_str
           kwargs[:query] = query_str
@@ -1643,6 +1510,9 @@ module GraphQL
           {
             backtrace: ctx[:backtrace],
             tracers: ctx[:tracers],
+            trace: ctx[:trace],
+            dataloader: ctx[:dataloader],
+            trace_mode: ctx[:trace_mode],
           }
         else
           {}
@@ -1667,17 +1537,12 @@ module GraphQL
       #   }
       #
       # @see {Query#initialize} for query keyword arguments
-      # @see {Execution::Multiplex#run_queries} for multiplex keyword arguments
+      # @see {Execution::Multiplex#run_all} for multiplex keyword arguments
       # @param queries [Array<Hash>] Keyword arguments for each query
       # @param context [Hash] Multiplex-level context
-      # @return [Array<Hash>] One result for each query in the input
+      # @return [Array<GraphQL::Query::Result>] One result for each query in the input
       def multiplex(queries, **kwargs)
-        schema = if interpreter?
-          self
-        else
-          graphql_definition
-        end
-        GraphQL::Execution::Multiplex.run_all(schema, queries, **kwargs)
+        GraphQL::Execution::Interpreter.run_all(self, queries, **kwargs)
       end
 
       def instrumenters
@@ -1689,24 +1554,111 @@ module GraphQL
 
       # @api private
       def add_subscription_extension_if_necessary
-        if interpreter? && !defined?(@subscription_extension_added) && subscription && self.subscriptions
+        # TODO: when there's a proper API for extending root types, migrat this to use it.
+        if !defined?(@subscription_extension_added) && @subscription_object.is_a?(Class) && 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.fields.each do |name, field|
+          subscription.all_field_definitions.each do |field|
+            if !field.extensions.any? { |ext| ext.is_a?(Subscriptions::DefaultSubscriptionResolveExtension) }
               field.extension(Subscriptions::DefaultSubscriptionResolveExtension)
             end
           end
         end
       end
 
+      # Called when execution encounters a `SystemStackError`. By default, it adds a client-facing error to the response.
+      # You could modify this method to report this error to your bug tracker.
+      # @param query [GraphQL::Query]
+      # @param err [SystemStackError]
+      # @return [void]
       def query_stack_error(query, err)
         query.context.errors.push(GraphQL::ExecutionError.new("This query is too large to execute."))
       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, &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
+
+      # Returns `DidYouMean` if it's defined.
+      # Override this to return `nil` if you don't want to use `DidYouMean`
+      def did_you_mean(new_dym = NOT_CONFIGURED)
+        if NOT_CONFIGURED.equal?(new_dym)
+          if defined?(@did_you_mean)
+            @did_you_mean
+          else
+            find_inherited_value(:did_you_mean, defined?(DidYouMean) ? DidYouMean : nil)
+          end
+        else
+          @did_you_mean = new_dym
+        end
+      end
+
       private
 
+      def add_trace_options_for(mode, new_options)
+        if mode == :default
+          own_trace_modes.each do |mode_name, t_class|
+            if t_class <= DefaultTraceClass
+              t_opts = trace_options_for(mode_name)
+              t_opts.merge!(new_options)
+            end
+          end
+        else
+          t_opts = trace_options_for(mode)
+          t_opts.merge!(new_options)
+        end
+        nil
+      end
+
       # @param t [Module, Array<Module>]
       # @return [void]
       def add_type_and_traverse(t, root:)
@@ -1716,12 +1668,42 @@ module GraphQL
         end
         new_types = Array(t)
         addition = Schema::Addition.new(schema: self, own_types: own_types, new_types: new_types)
-        own_types.merge!(addition.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
+
+            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) }
+          prev_refs = own_references_to[thing] || []
+          own_references_to[thing] = prev_refs | pointers.to_a
         }
 
         addition.directives.each { |dir_class| own_directives[dir_class.graphql_name] = dir_class }
@@ -1739,7 +1721,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)
+            @lazy_methods.set(GraphQL::Dataloader::Request, :load_with_deprecation_warning)
           end
         end
         @lazy_methods
@@ -1749,6 +1731,10 @@ module GraphQL
         @own_types ||= {}
       end
 
+      def own_references_to
+        @own_references_to ||= {}.compare_by_identity
+      end
+
       def non_introspection_types
         find_inherited_value(:non_introspection_types, EMPTY_HASH).merge(own_types)
       end
@@ -1762,7 +1748,7 @@ module GraphQL
       end
 
       def own_possible_types
-        @own_possible_types ||= {}
+        @own_possible_types ||= {}.compare_by_identity
       end
 
       def own_union_memberships
@@ -1785,68 +1771,40 @@ module GraphQL
         @defined_query_analyzers ||= []
       end
 
-      def all_middleware
-        find_inherited_value(:all_middleware, EMPTY_ARRAY) + own_middleware
-      end
-
-      def own_middleware
-        @own_middleware ||= []
-      end
-
       def own_multiplex_analyzers
         @own_multiplex_analyzers ||= []
       end
-    end
-
-    def dataloader_class
-      self.class.dataloader_class
-    end
-
-    # Install these here so that subclasses will also install it.
-    use(GraphQL::Pagination::Connections)
-
-    protected
-
-    def rescues?
-      !!@rescue_middleware
-    end
 
-    # Lazily create a middleware and add it to the schema
-    # (Don't add it if it's not used)
-    def rescue_middleware
-      @rescue_middleware ||= GraphQL::Schema::RescueMiddleware.new.tap { |m| middleware.insert(0, m) }
+      # This is overridden in subclasses to check the inheritance chain
+      def get_references_to(type_defn)
+        own_references_to[type_defn]
+      end
     end
 
-    private
-
-    def rebuild_artifacts
-      if @rebuilding_artifacts
-        raise CyclicalDefinitionError, "Part of the schema build process re-triggered the schema build process, causing an infinite loop. Avoid using Schema#types, Schema#possible_types, and Schema#get_field during schema build."
-      else
-        @rebuilding_artifacts = true
-        @introspection_system = Schema::IntrospectionSystem.new(self)
-        traversal = Traversal.new(self)
-        @types = traversal.type_map
-        @root_types = [query, mutation, subscription]
-        @instrumented_field_map = traversal.instrumented_field_map
-        @type_reference_map = traversal.type_reference_map
-        @union_memberships = traversal.union_memberships
-        @find_cache = {}
-        @finder = Finder.new(self)
-      end
-    ensure
-      @rebuilding_artifacts = false
+    module SubclassGetReferencesTo
+      def get_references_to(type_defn)
+        own_refs = own_references_to[type_defn]
+        inherited_refs = superclass.references_to(type_defn)
+        if inherited_refs&.any?
+          if own_refs&.any?
+            own_refs + inherited_refs
+          else
+            inherited_refs
+          end
+        else
+          own_refs
+        end
+      end
     end
 
-    class CyclicalDefinitionError < GraphQL::Error
-    end
+    # Install these here so that subclasses will also install it.
+    self.connections = GraphQL::Pagination::Connections.new(schema: self)
 
-    def with_definition_error_check
-      if @definition_error
-        raise @definition_error
-      else
-        yield
-      end
+    # @api private
+    module DefaultTraceClass
     end
   end
 end
+
+require "graphql/schema/loader"
+require "graphql/schema/printer"