graphql 1.10.0.pre1 → 1.10.0.pre2

data/lib/graphql/language/parser.rb

@@ -21,6 +21,7 @@ def initialize(query_string, filename:, tracer: Tracing::NullTracer)
   @query_string = query_string
   @filename = filename
   @tracer = tracer
+  @reused_next_token = [nil, nil]
 end
 
 def parse_document
@@ -51,7 +52,9 @@ def next_token
   if lexer_token.nil?
     nil
   else
-    [lexer_token.name, lexer_token]
+    @reused_next_token[0] = lexer_token.name
+    @reused_next_token[1] = lexer_token
+    @reused_next_token
   end
 end
 

data/lib/graphql/language/parser.y

@@ -442,6 +442,7 @@ def initialize(query_string, filename:, tracer: Tracing::NullTracer)
   @query_string = query_string
   @filename = filename
   @tracer = tracer
+  @reused_next_token = [nil, nil]
 end
 
 def parse_document
@@ -472,7 +473,9 @@ def next_token
   if lexer_token.nil?
     nil
   else
-    [lexer_token.name, lexer_token]
+    @reused_next_token[0] = lexer_token.name
+    @reused_next_token[1] = lexer_token
+    @reused_next_token
   end
 end
 

data/lib/graphql/language/token.rb

@@ -14,7 +14,7 @@ module GraphQL
       attr_reader :value
       attr_reader :prev_token, :line, :col
 
-      def initialize(value:, name:, line:, col:, prev_token:)
+      def initialize(name, value, line, col, prev_token)
         @name = name
         @value = -value
         @line = line

data/lib/graphql/pagination/array_connection.rb

@@ -68,7 +68,6 @@ module GraphQL
 
           limited_nodes = limited_nodes.first(first) if first
           limited_nodes = limited_nodes.last(last) if last
-          limited_nodes = limited_nodes.first(max_page_size) if max_page_size && !first && !last
 
           limited_nodes
         end

data/lib/graphql/pagination/connection.rb

@@ -26,7 +26,18 @@ module GraphQL
       # @return [GraphQL::Query::Context]
       attr_accessor :context
 
-      attr_accessor :before, :after
+      # Raw access to client-provided values. (`max_page_size` not applied to first or last.)
+      attr_accessor :before_value, :after_value, :first_value, :last_value
+
+      # @return [String, nil] the client-provided cursor
+      def before
+        @before_value
+      end
+
+      # @return [String, nil] the client-provided cursor
+      def after
+        @after_value
+      end
 
       # @param items [Object] some unpaginated collection item, like an `Array` or `ActiveRecord::Relation`
       # @param context [Query::Context]
@@ -34,13 +45,14 @@ module GraphQL
       # @param after [String, nil] A cursor for pagination, if the client provided one
       # @param last [Integer, nil] Limit parameter from the client, if provided
       # @param before [String, nil] A cursor for pagination, if the client provided one.
+      # @param max_page_size [Integer, nil] A configured value to cap the result size. Applied as `first` if neither first or last are given.
       def initialize(items, context: nil, first: nil, after: nil, max_page_size: nil, last: nil, before: nil)
         @items = items
         @context = context
-        @first = first
-        @after = after
-        @last = last
-        @before = before
+        @first_value = first
+        @after_value = after
+        @last_value = last
+        @before_value = before
         @max_page_size = max_page_size
       end
 
@@ -50,15 +62,24 @@ module GraphQL
       end
 
       attr_writer :first
-      # @return [Integer, nil] a clamped `first` value. (The underlying instance variable doesn't have limits on it)
+      # @return [Integer, nil]
+      #   A clamped `first` value.
+      #   (The underlying instance variable doesn't have limits on it.)
+      #   If neither `first` nor `last` is given, but `max_page_size` is present, max_page_size is used for first.
       def first
-        limit_pagination_argument(@first, max_page_size)
+        @first ||= begin
+          capped = limit_pagination_argument(@first_value, max_page_size)
+          if capped.nil? && last.nil?
+            capped = max_page_size
+          end
+          capped
+        end
       end
 
       attr_writer :last
-      # @return [Integer, nil] a clamped `last` value. (The underlying instance variable doesn't have limits on it)
+      # @return [Integer, nil] A clamped `last` value. (The underlying instance variable doesn't have limits on it)
       def last
-        limit_pagination_argument(@last, max_page_size)
+        @last ||= limit_pagination_argument(@last_value, max_page_size)
       end
 
       # @return [Array<Edge>] {nodes}, but wrapped with Edge instances
@@ -66,7 +87,7 @@ module GraphQL
         @edges ||= nodes.map { |n| self.class.edge_class.new(n, self) }
       end
 
-      # @return [Array<Object>] A slice of {items}, constrained by {@first}/{@after}/{@last}/{@before}
+      # @return [Array<Object>] A slice of {items}, constrained by {@first_value}/{@after_value}/{@last_value}/{@before_value}
       def nodes
         raise PaginationImplementationMissingError, "Implement #{self.class}#nodes to paginate `@items`"
       end

data/lib/graphql/pagination/connections.rb

@@ -29,8 +29,13 @@ module GraphQL
       end
 
       def self.use(schema_defn)
-        [schema_defn.target, schema_defn.target.class].each do |schema|
-          schema.connections = self.new
+        if schema_defn.is_a?(Class)
+          schema_defn.connections = self.new
+        else
+          # Unwrap a `.define` object
+          schema_defn = schema_defn.target
+          schema_defn.connections = self.new
+          schema_defn.class.connections = schema_defn.connections
         end
       end
 

data/lib/graphql/pagination/relation_connection.rb

@@ -53,6 +53,7 @@ module GraphQL
         raise "#{self.class}#null_relation(relation) must return an empty relation for a #{relation.class} (#{relation.inspect})"
       end
 
+      # @return [Integer]
       def offset_from_cursor(cursor)
         decode(cursor).to_i
       end
@@ -130,13 +131,6 @@ module GraphQL
             end
           end
 
-          # Apply max page size if nothing else was applied
-          if max_page_size && !first && !last
-            if relation_limit(paginated_nodes).nil? || relation_limit(paginated_nodes) > max_page_size
-              paginated_nodes = set_limit(paginated_nodes, max_page_size)
-            end
-          end
-
           @has_next_page = !!(
             (before_offset && before_offset > 0) ||
             (first && sliced_nodes_count > first)

data/lib/graphql/query.rb

@@ -78,12 +78,18 @@ module GraphQL
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
     # @param except [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns truthy
     # @param only [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns false
-    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, except: nil, only: nil)
+    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, except: nil, only: nil, warden: nil)
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
+
+      # Use the `.graphql_definition` here which will return legacy types instead of classes
+      if schema.is_a?(Class) && !schema.interpreter?
+        schema = schema.graphql_definition
+      end
       @schema = schema
       @filter = schema.default_filter.merge(except: except, only: only)
       @context = schema.context_class.new(query: self, object: root_value, values: context)
+      @warden = warden
       @subscription_topic = subscription_topic
       @root_value = root_value
       @fragments = nil
@@ -157,7 +163,7 @@ module GraphQL
       @lookahead ||= begin
         ast_node = selected_operation
         root_type = warden.root_type_for_operation(ast_node.operation_type || "query")
-        root_type = root_type.metadata[:type_class] || raise("Invariant: `lookahead` only works with class-based types")
+        root_type = root_type.type_class || raise("Invariant: `lookahead` only works with class-based types")
         GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [ast_node])
       end
     end
@@ -314,8 +320,7 @@ module GraphQL
 
     def prepare_ast
       @prepared_ast = true
-      @warden = GraphQL::Schema::Warden.new(@filter, schema: @schema, context: @context)
-
+      @warden ||= GraphQL::Schema::Warden.new(@filter, schema: @schema, context: @context)
       parse_error = nil
       @document ||= begin
         if query_string

data/lib/graphql/query/arguments.rb

@@ -88,6 +88,10 @@ module GraphQL
 
       def_delegators :to_h, :keys, :values, :each, :any?
 
+      def prepare
+        self
+      end
+
       # Access each key, value and type for the arguments in this set.
       # @yield [argument_value] The {ArgumentValue} for each argument
       # @yieldparam argument_value [ArgumentValue]
@@ -119,6 +123,8 @@ module GraphQL
         ruby_kwargs
       end
 
+      alias :to_hash :to_kwargs
+
       private
 
       class ArgumentValue
@@ -151,7 +157,8 @@ module GraphQL
             wrap_value(value, arg_defn_type.of_type, context)
           when GraphQL::InputObjectType
             if value.is_a?(Hash)
-              arg_defn_type.arguments_class.new(value, context: context, defaults_used: Set.new)
+              result = arg_defn_type.arguments_class.new(value, context: context, defaults_used: Set.new)
+              result.prepare
             else
               value
             end

data/lib/graphql/query/literal_input.rb

@@ -127,7 +127,8 @@ module GraphQL
             ruby_kwargs
           end
         else
-          argument_owner.arguments_class.new(values_hash, context: context, defaults_used: defaults_used)
+          result = argument_owner.arguments_class.new(values_hash, context: context, defaults_used: defaults_used)
+          result.prepare
         end
       end
     end

data/lib/graphql/query/variables.rb

@@ -35,7 +35,11 @@ module GraphQL
               if validation_result.valid?
                 if value_was_provided
                   # Add the variable if a value was provided
-                  memo[variable_name] = variable_type.coerce_input(provided_value, ctx)
+                  memo[variable_name] = if provided_value.nil?
+                    nil
+                  else
+                    variable_type.coerce_input(provided_value, ctx)
+                  end
                 elsif default_value != nil
                   # Add the variable if it wasn't provided but it has a default value (including `null`)
                   memo[variable_name] = GraphQL::Query::LiteralInput.coerce(variable_type, default_value, self)

data/lib/graphql/relay/base_connection.rb

@@ -143,7 +143,7 @@ module GraphQL
 
       # An opaque operation which returns a connection-specific cursor.
       def cursor_from_node(object)
-        raise NotImplementedError, "must return a cursor for this object/connection pair"
+        raise GraphQL::RequiredImplementationMissingError, "must return a cursor for this object/connection pair"
       end
 
       def inspect
@@ -165,11 +165,11 @@ module GraphQL
       end
 
       def paged_nodes
-        raise NotImplementedError, "must return nodes for this connection after paging"
+        raise GraphQL::RequiredImplementationMissingError, "must return nodes for this connection after paging"
       end
 
       def sliced_nodes
-        raise NotImplementedError, "must return  all nodes for this connection after chopping off first and last"
+        raise GraphQL::RequiredImplementationMissingError, "must return  all nodes for this connection after chopping off first and last"
       end
     end
   end

data/lib/graphql/relay/relation_connection.rb

@@ -25,12 +25,16 @@ module GraphQL
 
       def has_next_page
         if first
-          paged_nodes.length >= first && sliced_nodes_count > first
-        elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && last
-          sliced_nodes_count >= last
-        else
-          false
+          if defined?(ActiveRecord::Relation) && nodes.is_a?(ActiveRecord::Relation)
+            initial_offset = after ? offset_from_cursor(after) : 0
+            return paged_nodes.length >= first && nodes.offset(first + initial_offset).exists?
+          end
+          return paged_nodes.length >= first && sliced_nodes_count > first
+        end
+        if GraphQL::Relay::ConnectionType.bidirectional_pagination && last
+          return sliced_nodes_count >= last
         end
+        false
       end
 
       def has_previous_page

data/lib/graphql/schema.rb

@@ -36,6 +36,7 @@ require "graphql/schema/scalar"
 require "graphql/schema/object"
 require "graphql/schema/union"
 require "graphql/schema/directive"
+require "graphql/schema/directive/deprecated"
 require "graphql/schema/directive/include"
 require "graphql/schema/directive/skip"
 require "graphql/schema/directive/feature"
@@ -54,7 +55,6 @@ module GraphQL
   #  - types for exposing your application
   #  - query analyzers for assessing incoming queries (including max depth & max complexity restrictions)
   #  - execution strategies for running incoming queries
-  #  - middleware for interacting with execution
   #
   # Schemas start with root types, {Schema#query}, {Schema#mutation} and {Schema#subscription}.
   # The schema will traverse the tree of fields & types, using those as starting points.
@@ -66,14 +66,10 @@ module GraphQL
   # 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.
-  #
-  # A schema accepts a `Relay::GlobalNodeIdentification` instance for use with Relay IDs.
-  #
+  #  #
   # @example defining a schema
-  #   MySchema = GraphQL::Schema.define do
+  #   class MySchema < GraphQL::Schema
   #     query QueryType
-  #     middleware PermissionMiddleware
-  #     rescue_from(ActiveRecord::RecordNotFound) { "Not found" }
   #     # If types are only connected by way of interfaces, they must be added here
   #     orphan_types ImageType, AudioType
   #   end
@@ -85,6 +81,14 @@ module GraphQL
     include GraphQL::Define::InstanceDefinable
     extend GraphQL::Schema::FindInheritedValue
 
+    class UnresolvedLateBoundTypeError < GraphQL::Error
+      attr_reader :type
+      def initialize(type:)
+        @type = type
+        super("Late bound type was never found: #{type.inspect}")
+      end
+    end
+
     accepts_definitions \
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
       :max_depth, :max_complexity, :default_max_page_size,
@@ -99,7 +103,7 @@ module GraphQL
       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 },
-      directives: ->(schema, directives) { schema.directives = directives.reduce({}) { |m, d| m[d.name] = d; m } },
+      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
@@ -154,6 +158,10 @@ module GraphQL
     # [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
+
     class << self
       attr_writer :default_execution_strategy
     end
@@ -167,8 +175,6 @@ module GraphQL
     attr_reader :tracers
 
     DYNAMIC_FIELDS = ["__type", "__typename", "__schema"].freeze
-    EMPTY_ARRAY = [].freeze
-    EMPTY_HASH = {}.freeze
 
     attr_reader :static_validator, :object_from_id_proc, :id_from_object_proc, :resolve_type_proc
 
@@ -176,7 +182,10 @@ module GraphQL
       @tracers = []
       @definition_error = nil
       @orphan_types = []
-      @directives = self.class.default_directives
+      @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 = []
@@ -282,13 +291,13 @@ module GraphQL
       ensure_defined
       # Assert that all necessary configs are present:
       validation_error = Validation.validate(self)
-      validation_error && raise(NotImplementedError, validation_error)
+      validation_error && raise(GraphQL::RequiredImplementationMissingError, validation_error)
       rebuild_artifacts
 
       @definition_error = nil
       nil
     rescue StandardError => err
-      if @raise_definition_error || err.is_a?(CyclicalDefinitionError)
+      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
@@ -325,6 +334,10 @@ module GraphQL
       end
     end
 
+    def get_type(type_name)
+      @types[type_name]
+    end
+
     # @api private
     def introspection_system
       @introspection_system ||= begin
@@ -336,9 +349,13 @@ module GraphQL
     # Returns a list of Arguments and Fields referencing a certain type
     # @param type_name [String]
     # @return [Hash]
-    def references_to(type_name)
+    def references_to(type_name = nil)
       rebuild_artifacts unless defined?(@type_reference_map)
-      @type_reference_map.fetch(type_name, [])
+      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
@@ -416,8 +433,8 @@ module GraphQL
     def get_field(parent_type, field_name)
       with_definition_error_check do
         parent_type_name = case parent_type
-        when GraphQL::BaseType
-          parent_type.name
+        when GraphQL::BaseType, Class, Module
+          parent_type.graphql_name
         when String
           parent_type
         else
@@ -444,7 +461,7 @@ module GraphQL
     end
 
     def type_from_ast(ast_node, context:)
-      GraphQL::Schema::TypeExpression.build_type(self.types, ast_node)
+      GraphQL::Schema::TypeExpression.build_type(self, ast_node)
     end
 
     # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
@@ -493,7 +510,7 @@ module 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(NotImplementedError, "Can't determine GraphQL type for: #{ok_object.inspect}, define `resolve_type (type, obj, ctx) -> { ... }` inside `Schema.define`.")
+          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
@@ -554,7 +571,7 @@ module GraphQL
     # @return [Any] The application object identified by `id`
     def object_from_id(id, ctx)
       if @object_from_id_proc.nil?
-        raise(NotImplementedError, "Can't fetch an object for id \"#{id}\" because the schema's `object_from_id (id, ctx) -> { ... }` function is not defined")
+        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
@@ -596,9 +613,40 @@ module GraphQL
 
     # Can't delegate to `class`
     alias :_schema_class :class
-    def_delegators :_schema_class, :visible?, :accessible?, :authorized?, :unauthorized_object, :unauthorized_field, :inaccessible_fields
+    def_delegators :_schema_class, :unauthorized_object, :unauthorized_field, :inaccessible_fields
     def_delegators :_schema_class, :directive
 
+
+    # 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
+      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.
@@ -621,7 +669,7 @@ module GraphQL
     # @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(NotImplementedError, "Can't generate an ID for #{object.inspect} of type #{type}, schema's `id_from_object` must be defined")
+        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
@@ -643,15 +691,17 @@ module GraphQL
     # @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`)
-    # @return [GraphQL::Schema] the schema described by `document`
-    def self.from_definition(definition_or_path, default_resolve: BuildFromDefinition::DefaultResolve, parser: BuildFromDefinition::DefaultParser)
+    # @param using [Hash] Plugins to attach to the created schema with `use(key, value)`
+    # @param interpreter [Boolean] If false, the legacy {Execution::Execute} runtime will be used
+    # @return [Class] the schema described by `document`
+    def self.from_definition(definition_or_path, default_resolve: BuildFromDefinition::DefaultResolve, interpreter: true, parser: BuildFromDefinition::DefaultParser, using: {})
       # If the file ends in `.graphql`, treat it like a filepath
       definition = if definition_or_path.end_with?(".graphql")
         File.read(definition_or_path)
       else
         definition_or_path
       end
-      GraphQL::Schema::BuildFromDefinition.from_definition(definition, default_resolve: default_resolve, parser: parser)
+      GraphQL::Schema::BuildFromDefinition.from_definition(definition, default_resolve: default_resolve, parser: parser, using: using, interpreter: interpreter)
     end
 
     # Error that is raised when [#Schema#from_definition] is passed an invalid schema definition string.
@@ -711,38 +761,83 @@ module GraphQL
       # - Delegate to that instance
       # Eventually, the methods will be moved into this class, removing the need for the singleton.
       def_delegators :graphql_definition,
-        # Schema structure
-        :as_json, :to_json, :to_document, :to_definition,
         # Execution
-        :execute, :multiplex,
-        :static_validator, :introspection_system,
-        :query_analyzers, :tracers, :instrumenters,
         :execution_strategy_for_operation,
-        :validate, :multiplex_analyzers, :lazy?, :lazy_method_name, :after_lazy, :sync_lazy,
+        :validate, :multiplex_analyzers,
         # Configuration
-        :analysis_engine, :analysis_engine=, :using_ast_analysis?, :interpreter?,
-        :max_complexity=, :max_depth=,
-        :error_bubbling=,
-        :metadata,
-        :default_mask,
-        :default_filter, :redefine,
+        :metadata, :redefine,
         :id_from_object_proc, :object_from_id_proc,
         :id_from_object=, :object_from_id=,
-        :remove_handler,
-        # Members
-        :types, :get_fields, :find,
-        :root_type_for_operation,
-        :subscriptions,
-        :union_memberships,
-        :get_field, :root_types, :references_to, :type_from_ast,
-        :possible_types,
-        :disable_introspection_entry_points=
+        :remove_handler
+
+      # @return [GraphQL::Subscriptions]
+      attr_accessor :subscriptions
+
+      # Returns the JSON response of {Introspection::INTROSPECTION_QUERY}.
+      # @see {#as_json}
+      # @return [String]
+      def to_json(*args)
+        JSON.pretty_generate(as_json(*args))
+      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::INTROSPECTION_QUERY, only: only, except: except, 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)
+      end
+
+      # Return the GraphQL::Language::Document IDL AST for the schema
+      # @return [GraphQL::Language::Document]
+      def to_document
+        GraphQL::Language::DocumentFromSchemaDefinition.new(self).document
+      end
+
+      def find(path)
+        if !@finder
+          @find_cache = {}
+          @finder ||= GraphQL::Schema::Finder.new(self)
+        end
+        @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
+
       def use(plugin, options = {})
+        if options.any?
+          plugin.use(self, options)
+        else
+          plugin.use(self)
+        end
         own_plugins << [plugin, options]
       end
 
@@ -753,14 +848,14 @@ module GraphQL
       def to_graphql
         schema_defn = self.new
         schema_defn.raise_definition_error = true
-        schema_defn.query = query
-        schema_defn.mutation = mutation
-        schema_defn.subscription = subscription
+        schema_defn.query = query && query.graphql_definition
+        schema_defn.mutation = mutation && mutation.graphql_definition
+        schema_defn.subscription = subscription && subscription.graphql_definition
         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
+        schema_defn.orphan_types = orphan_types.map(&:graphql_definition)
         schema_defn.disable_introspection_entry_points = disable_introspection_entry_points?
 
         prepped_dirs = {}
@@ -781,33 +876,24 @@ module GraphQL
         schema_defn.query_execution_strategy = query_execution_strategy
         schema_defn.mutation_execution_strategy = mutation_execution_strategy
         schema_defn.subscription_execution_strategy = subscription_execution_strategy
-        all_instrumenters.each do |step, insts|
+        schema_defn.default_mask = default_mask
+        instrumenters.each do |step, insts|
           insts.each do |inst|
             schema_defn.instrumenters[step] << inst
           end
         end
-        lazy_classes.each do |lazy_class, value_method|
+
+        lazy_methods.each do |lazy_class, value_method|
           schema_defn.lazy_methods.set(lazy_class, value_method)
         end
+
         rescues.each do |err_class, handler|
           schema_defn.rescue_from(err_class, &handler)
         end
 
-        if plugins.any?
-          schema_plugins = plugins
-          # TODO don't depend on .define
-          schema_defn = schema_defn.redefine do
-            schema_plugins.each do |plugin, options|
-              if options.any?
-                use(plugin, **options)
-              else
-                use(plugin)
-              end
-            end
-          end
-        end
-        # Do this after `plugins` since Interpreter is a plugin
-        if schema_defn.query_execution_strategy != GraphQL::Execution::Interpreter
+        schema_defn.subscriptions ||= self.subscriptions
+
+        if !schema_defn.interpreter?
           schema_defn.instrumenters[:query] << GraphQL::Schema::Member::Instrumentation
         end
         schema_defn.send(:rebuild_artifacts)
@@ -815,44 +901,196 @@ module GraphQL
         schema_defn
       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]
+      end
+
       # @return [GraphQL::Pagination::Connections] if installed
       attr_accessor :connections
 
+      def new_connections?
+        !!connections
+      end
+
       def query(new_query_object = nil)
         if new_query_object
-          @query_object = new_query_object
+          if @query_object
+            raise GraphQL::Error, "Second definition of `query(...)` (#{new_query_object.inspect}) is invalid, already configured with #{@query_object.inspect}"
+          else
+            @query_object = new_query_object
+            add_type_and_traverse(new_query_object, root: true)
+            nil
+          end
         else
-          query_object = @query_object || find_inherited_value(:query)
-          query_object.respond_to?(:graphql_definition) ? query_object.graphql_definition : query_object
+          @query_object || find_inherited_value(:query)
         end
       end
 
       def mutation(new_mutation_object = nil)
         if new_mutation_object
-          @mutation_object = new_mutation_object
+          if @mutation_object
+            raise GraphQL::Error, "Second definition of `mutation(...)` (#{new_mutation_object.inspect}) is invalid, already configured with #{@mutation_object.inspect}"
+          else
+            @mutation_object = new_mutation_object
+            add_type_and_traverse(new_mutation_object, root: true)
+            nil
+          end
         else
-          mutation_object = @mutation_object || find_inherited_value(:mutation)
-          mutation_object.respond_to?(:graphql_definition) ? mutation_object.graphql_definition : mutation_object
+          @mutation_object || find_inherited_value(:mutation)
         end
       end
 
       def subscription(new_subscription_object = nil)
         if new_subscription_object
-          @subscription_object = new_subscription_object
+          if @subscription_object
+            raise GraphQL::Error, "Second definition of `subscription(...)` (#{new_subscription_object.inspect}) is invalid, already configured with #{@subscription_object.inspect}"
+          else
+            @subscription_object = new_subscription_object
+            add_type_and_traverse(new_subscription_object, root: true)
+            nil
+          end
+        else
+          @subscription_object || find_inherited_value(:subscription)
+        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 root_types
+        @root_types
+      end
+
+      # @param type [Module] The type definition whose possible types you want to see
+      # @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)
+        if type
+          own_possible_types[type.graphql_name] ||
+            find_inherited_value(:possible_types, EMPTY_HASH)[type.graphql_name] ||
+            EMPTY_ARRAY
+        else
+          find_inherited_value(:possible_types, EMPTY_HASH)
+            .merge(own_possible_types)
+            .merge(introspection_system.possible_types)
+        end
+      end
+
+      def union_memberships(type = nil)
+        if type
+          own_um = own_union_memberships.fetch(type.graphql_name, EMPTY_ARRAY)
+          inherited_um = find_inherited_value(:union_memberships, EMPTY_HASH).fetch(type.graphql_name, EMPTY_ARRAY)
+          own_um + inherited_um
+        else
+          joined_um = own_union_memberships.dup
+          find_inherited_value(:union_memberhips, EMPTY_HASH).each do |k, v|
+            um = joined_um[k] ||= []
+            um.concat(v)
+          end
+          joined_um
+        end
+      end
+
+      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
+          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
+          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)
+          else
+            @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)
+      end
+
+      def get_field(type_or_name, field_name)
+        parent_type = case type_or_name
+        when LateBoundType
+          get_type(type_or_name.name)
+        when String
+          get_type(type_or_name)
+        when Module
+          type_or_name
         else
-          subscription_object = @subscription_object || find_inherited_value(:subscription)
-          subscription_object.respond_to?(:graphql_definition) ? subscription_object.graphql_definition : subscription_object
+          raise ArgumentError, "unexpected field owner for #{field_name.inspect}: #{type_or_name.inspect} (#{type_or_name.class})"
+        end
+
+        if parent_type.kind.fields? && (field = parent_type.get_field(field_name))
+          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
+        else
+          nil
         end
       end
 
+      def get_fields(type)
+        type.fields
+      end
+
       def introspection(new_introspection_namespace = nil)
         if new_introspection_namespace
           @introspection = new_introspection_namespace
+          # reset this cached value:
+          @introspection_system = nil
         else
           @introspection || find_inherited_value(:introspection)
         end
       end
 
+      def introspection_system
+        if !@introspection_system
+          @introspection_system = Schema::IntrospectionSystem.new(self)
+          @introspection_system.resolve_late_bindings
+        end
+        @introspection_system
+      end
+
       def cursor_encoder(new_encoder = nil)
         if new_encoder
           @cursor_encoder = new_encoder
@@ -892,14 +1130,38 @@ module GraphQL
         end
       end
 
+      attr_writer :max_complexity
+
       def max_complexity(max_complexity = nil)
         if max_complexity
           @max_complexity = max_complexity
+        elsif defined?(@max_complexity)
+          @max_complexity
         else
-          @max_complexity || find_inherited_value(:max_complexity)
+          find_inherited_value(:max_complexity)
         end
       end
 
+      attr_writer :analysis_engine
+
+      def analysis_engine
+        @analysis_engine || find_inherited_value(:analysis_engine, GraphQL::Analysis)
+      end
+
+      def using_ast_analysis?
+        analysis_engine == GraphQL::Analysis::AST
+      end
+
+      def interpreter?
+        if defined?(@interpreter)
+          @interpreter
+        else
+          find_inherited_value(:interpreter?, false)
+        end
+      end
+
+      attr_writer :interpreter
+
       def error_bubbling(new_error_bubbling = nil)
         if !new_error_bubbling.nil?
           @error_bubbling = new_error_bubbling
@@ -908,16 +1170,24 @@ module GraphQL
         end
       end
 
+      attr_writer :error_bubbling
+
+      attr_writer :max_depth
+
       def max_depth(new_max_depth = nil)
         if new_max_depth
           @max_depth = new_max_depth
+        elsif defined?(@max_depth)
+          @max_depth
         else
-          @max_depth || find_inherited_value(:max_depth)
+          find_inherited_value(:max_depth)
         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.
+        @introspection_system = nil
       end
 
       def disable_introspection_entry_points?
@@ -930,6 +1200,9 @@ module GraphQL
 
       def orphan_types(*new_orphan_types)
         if new_orphan_types.any?
+          new_orphan_types = new_orphan_types.flatten
+          add_type_and_traverse(new_orphan_types, root: false)
+          @orphan_types = new_orphan_types
           own_orphan_types.concat(new_orphan_types.flatten)
         end
 
@@ -958,32 +1231,60 @@ module GraphQL
         end
       end
 
-      def rescues
-        find_inherited_value(:rescues, EMPTY_HASH).merge(own_rescues)
+      # rubocop:disable Lint/DuplicateMethods
+      module ResolveTypeWithType
+        def resolve_type(type, obj, ctx)
+          first_resolved_type = if type.is_a?(Module) && type.respond_to?(:resolve_type)
+            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)
+              resolved_type
+            else
+              raise ".resolve_type should return a type definition, but got #{resolved_type.inspect} (#{resolved_type.class}) from `resolve_type(#{type}, #{obj}, #{ctx})`"
+            end
+          end
+        end
       end
 
       def resolve_type(type, obj, ctx)
         if type.kind.object?
           type
         else
-          raise NotImplementedError, "#{self.name}.resolve_type(type, obj, ctx) must be implemented to use Union types or Interface types (tried to resolve: #{type.name})"
+          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
       end
+      # rubocop:enable Lint/DuplicateMethods
+
+      def inherited(child_class)
+        if self == GraphQL::Schema
+          child_class.directives(default_directives.values)
+        end
+        child_class.singleton_class.prepend(ResolveTypeWithType)
+        super
+      end
+
+      def rescues
+        find_inherited_value(:rescues, EMPTY_HASH).merge(own_rescues)
+      end
 
       def object_from_id(node_id, ctx)
-        raise NotImplementedError, "#{self.name}.object_from_id(node_id, ctx) must be implemented to load by ID (tried to load from id `#{node_id}`)"
+        raise GraphQL::RequiredImplementationMissingError, "#{self.name}.object_from_id(node_id, ctx) must be implemented to load by ID (tried to load from id `#{node_id}`)"
       end
 
       def id_from_object(object, type, ctx)
-        raise NotImplementedError, "#{self.name}.id_from_object(object, type, ctx) must be implemented to create global ids (tried to create an id for `#{object.inspect}`)"
+        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}`)"
       end
 
-      def visible?(member, context)
-        call_on_type_class(member, :visible?, context, default: true)
+      def visible?(member, ctx)
+        member.visible?(ctx)
       end
 
-      def accessible?(member, context)
-        call_on_type_class(member, :accessible?, context, default: true)
+      def accessible?(member, ctx)
+        member.accessible?(ctx)
       end
 
       # This hook is called when a client tries to access one or more
@@ -1037,8 +1338,18 @@ module GraphQL
         DefaultTypeError.call(type_err, ctx)
       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 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
+
       def lazy_resolve(lazy_class, value_method)
-        lazy_classes[lazy_class] = value_method
+        lazy_methods.set(lazy_class, value_method)
       end
 
       def instrument(instrument_step, instrumenter, options = {})
@@ -1051,23 +1362,28 @@ module GraphQL
         own_instrumenters[step] << instrumenter
       end
 
+      # Add several directives at once
+      # @param new_directives [Class]
       def directives(new_directives = nil)
         if new_directives
-          new_directives.each {|d| directive(d) }
+          new_directives.each { |d| directive(d) }
         end
 
         find_inherited_value(:directives, default_directives).merge(own_directives)
       end
 
+      # Attach a single directive to this schema
+      # @param new_directive [Class]
       def directive(new_directive)
+        add_type_and_traverse(new_directive, root: false)
         own_directives[new_directive.graphql_name] = new_directive
       end
 
       def default_directives
         {
-          "include" => GraphQL::Directive::IncludeDirective,
-          "skip" => GraphQL::Directive::SkipDirective,
-          "deprecated" => GraphQL::Directive::DeprecatedDirective,
+          "include" => GraphQL::Schema::Directive::Include,
+          "skip" => GraphQL::Schema::Directive::Skip,
+          "deprecated" => GraphQL::Schema::Directive::Deprecated,
         }
       end
 
@@ -1094,7 +1410,8 @@ module GraphQL
         if new_middleware
           own_middleware << new_middleware
         else
-          graphql_definition.middleware
+          # TODO make sure this is cached when running a query
+          MiddlewareChain.new(steps: all_middleware, final_step: GraphQL::Execution::Execute::FieldResolveStep)
         end
       end
 
@@ -1106,10 +1423,125 @@ module GraphQL
         find_inherited_value(:multiplex_analyzers, EMPTY_ARRAY) + own_multiplex_analyzers
       end
 
+      # Execute a query on itself.
+      # @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
+          {}
+        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, concurrently.
+      #
+      # @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)
+        schema = if interpreter?
+          self
+        else
+          graphql_definition
+        end
+        GraphQL::Execution::Multiplex.run_all(schema, queries, **kwargs)
+      end
+
+      def instrumenters
+        inherited_instrumenters = find_inherited_value(:instrumenters) || Hash.new { |h,k| h[k] = [] }
+        inherited_instrumenters.merge(own_instrumenters) do |_step, inherited, own|
+          inherited + own
+        end
+      end
+
+      # Call the given block at the right time, either:
+      # - Right away, if `value` is not registered with `lazy_resolve`
+      # - After resolving `value`, if it's registered with `lazy_resolve` (eg, `Promise`)
+      # @api private
+      def after_lazy(value)
+        if lazy?(value)
+          GraphQL::Execution::Lazy.new do
+            result = sync_lazy(value)
+            # The returned result might also be lazy, so check it, too
+            after_lazy(result) do |final_result|
+              yield(final_result) if block_given?
+            end
+          end
+        else
+          yield(value) if block_given?
+        end
+      end
+
+      # Override this method to handle lazy objects in a custom way.
+      # @param value [Object] an instance of a class registered with {.lazy_resolve}
+      # @param ctx [GraphQL::Query::Context] the context for this query
+      # @return [Object] A GraphQL-ready (non-lazy) object
+      def sync_lazy(value)
+        lazy_method = lazy_method_name(value)
+        if lazy_method
+          synced_value = value.public_send(lazy_method)
+          sync_lazy(synced_value)
+        else
+          value
+        end
+      end
+
+      # @return [Symbol, nil] The method name to lazily resolve `obj`, or nil if `obj`'s class wasn't registered wtih {#lazy_resolve}.
+      def lazy_method_name(obj)
+        lazy_methods.get(obj)
+      end
+
+      # @return [Boolean] True if this object should be lazily resolved
+      def lazy?(obj)
+        !!lazy_method_name(obj)
+      end
+
       private
 
-      def lazy_classes
-        @lazy_classes ||= {}
+      def lazy_methods
+        if !defined?(@lazy_methods)
+          if inherited_map = find_inherited_value(:lazy_methods)
+            # this isn't _completely_ inherited :S (Things added after `dup` won't work)
+            @lazy_methods = inherited_map.dup
+          else
+            @lazy_methods = GraphQL::Execution::Lazy::LazyMethodMap.new
+            @lazy_methods.set(GraphQL::Execution::Lazy, :value)
+          end
+        end
+        @lazy_methods
+      end
+
+      def own_types
+        @own_types ||= {}
+      end
+
+      def non_introspection_types
+        find_inherited_value(:non_introspection_types, EMPTY_HASH).merge(own_types)
       end
 
       def own_plugins
@@ -1124,15 +1556,16 @@ module GraphQL
         @own_orphan_types ||= []
       end
 
-      def own_directives
-        @own_directives ||= {}
+      def own_possible_types
+        @own_possible_types ||= {}
       end
 
-      def all_instrumenters
-        inherited_instrumenters = find_inherited_value(:all_instrumenters) || Hash.new { |h,k| h[k] = [] }
-        inherited_instrumenters.merge(own_instrumenters) do |_step, inherited, own|
-          inherited + own
-        end
+      def own_union_memberships
+        @own_union_memberships ||= {}
+      end
+
+      def own_directives
+        @own_directives ||= {}
       end
 
       def own_instrumenters
@@ -1159,42 +1592,172 @@ module GraphQL
         @own_multiplex_analyzers ||= []
       end
 
-      # Given this schema member, find the class-based definition object
-      # whose `method_name` should be treated as an application hook
-      # @see {.visible?}
-      # @see {.accessible?}
-      # @see {.authorized?}
-      def call_on_type_class(member, method_name, *args, default:)
-        member = if member.respond_to?(:metadata) && member.metadata
-          member.metadata[:type_class] || member
-        else
-          member
+      # @param t [Module, Array<Module>]
+      # @return [void]
+      def add_type_and_traverse(t, root:)
+        if root
+          @root_types ||= []
+          @root_types << t
         end
-
-        if member.respond_to?(:relay_node_type) && (t = member.relay_node_type)
-          member = t
+        late_types = []
+        new_types = Array(t)
+        new_types.each { |t| add_type(t, owner: nil, late_types: late_types) }
+        missed_late_types = 0
+        while (late_type_vals = late_types.shift)
+          type_owner, lt = late_type_vals
+          if lt.is_a?(String)
+            type = Member::BuildType.constantize(lt)
+            # Reset the counter, since we might succeed next go-round
+            missed_late_types = 0
+            update_type_owner(type_owner, type)
+            add_type(type, owner: type_owner, late_types: late_types)
+          elsif lt.is_a?(LateBoundType)
+            if (type = get_type(lt.graphql_name))
+              # Reset the counter, since we might succeed next go-round
+              missed_late_types = 0
+              update_type_owner(type_owner, type)
+              add_type(type, owner: type_owner, late_types: late_types)
+            else
+              missed_late_types += 1
+              # Add it back to the list, maybe we'll be able to resolve it later.
+              late_types << [type_owner, lt]
+              if missed_late_types == late_types.size
+                # We've looked at all of them and haven't resolved one.
+                raise UnresolvedLateBoundTypeError.new(type: lt)
+              else
+                # Try the next one
+              end
+            end
+          else
+            raise ArgumentError, "Unexpected late type: #{lt.inspect}"
+          end
         end
+        nil
+      end
 
-        if member.respond_to?(method_name)
-          member.public_send(method_name, *args)
+      def update_type_owner(owner, type)
+        case owner
+        when Class
+          if owner.kind.union?
+            # It's a union with possible_types
+            # Replace the item by class name
+            new_possible_types = owner.possible_types.map { |t|
+              if t.is_a?(String) && (t == type.name)
+                # This is a match of Ruby class names, not graphql names,
+                # since strings are used to refer to constants.
+                type
+              elsif t.is_a?(LateBoundType) && t.graphql_name == type.graphql_name
+                type
+              else
+                t
+              end
+            }
+            owner.possible_types(*new_possible_types)
+            own_possible_types[owner.graphql_name] = owner.possible_types
+          elsif type.kind.interface? && owner.kind.object?
+            new_interfaces = owner.interfaces.map do |t|
+              if t.is_a?(String) && t == type.graphql_name
+                type
+              elsif t.is_a?(LateBoundType) && t.graphql_name == type.graphql_name
+                type
+              else
+                t
+              end
+            end
+            owner.implements(*new_interfaces)
+          end
+
+        when nil
+          # It's a root type
+          own_types[type.graphql_name] = type
+        when GraphQL::Schema::Field, GraphQL::Schema::Argument
+          orig_type = owner.type
+          # Apply list/non-null wrapper as needed
+          if orig_type.respond_to?(:of_type)
+            transforms = []
+            while (orig_type.respond_to?(:of_type))
+              if orig_type.kind.non_null?
+                transforms << :to_non_null_type
+              elsif orig_type.kind.list?
+                transforms << :to_list_type
+              else
+                raise "Invariant: :of_type isn't non-null or list"
+              end
+              orig_type = orig_type.of_type
+            end
+            transforms.reverse_each { |t| type = type.public_send(t) }
+          end
+          owner.type = type
         else
-          default
+          raise "Unexpected update: #{owner.inspect} #{type.inspect}"
         end
       end
-    end
 
+      def add_type(type, owner:, late_types:)
+        if type.respond_to?(:metadata) && type.metadata.is_a?(Hash)
+          type_class = type.metadata[:type_class]
+          if type_class.nil?
+            raise ArgumentError, "Can't add legacy type: #{type} (#{type.class})"
+          else
+            type = type_class
+          end
+        elsif type.is_a?(String) || type.is_a?(GraphQL::Schema::LateBoundType)
+          late_types << [owner, type]
+          return
+        end
 
-    def self.inherited(child_class)
-      child_class.singleton_class.class_eval do
-        prepend(MethodWrappers)
-      end
-    end
+        if owner.is_a?(Class) && owner < GraphQL::Schema::Union
+          um = own_union_memberships[type.graphql_name] ||= []
+          um << owner
+        end
 
-    module MethodWrappers
-      # Wrap the user-provided resolve-type in a correctness check
-      def resolve_type(type, obj, ctx = :__undefined__)
-        graphql_definition.check_resolved_type(type, obj, ctx) do |ok_type, ok_obj, ok_ctx|
-          super(ok_type, ok_obj, ok_ctx)
+        if (prev_type = own_types[type.graphql_name])
+          if prev_type != type
+            raise ArgumentError, "Conflicting type definitions for `#{type.graphql_name}`: #{prev_type} (#{prev_type.class}), #{type} #{type.class}"
+          else
+            # This type was already added
+          end
+        elsif type.is_a?(Class) && type < GraphQL::Schema::Directive
+          type.arguments.each do |_name, arg|
+            arg_type = arg.type.unwrap
+            references_to(arg_type, from: arg)
+            add_type(arg_type, owner: arg, late_types: late_types)
+          end
+        else
+          own_types[type.graphql_name] = type
+          if type.kind.fields?
+            type.fields.each do |_name, field|
+              field_type = field.type.unwrap
+              references_to(field_type, from: field)
+              add_type(field_type, owner: field, late_types: late_types)
+              field.arguments.each do |_name, arg|
+                arg_type = arg.type.unwrap
+                references_to(arg_type, from: arg)
+                add_type(arg_type, owner: arg, late_types: late_types)
+              end
+            end
+          end
+          if type.kind.input_object?
+            type.arguments.each do |_name, arg|
+              arg_type = arg.type.unwrap
+              references_to(arg_type, from: arg)
+              add_type(arg_type, owner: arg, late_types: late_types)
+            end
+          end
+          if type.kind.union?
+            own_possible_types[type.graphql_name] = type.possible_types
+            type.possible_types.each do |t|
+              add_type(t, owner: type, late_types: late_types)
+            end
+          end
+          if type.kind.object?
+            own_possible_types[type.graphql_name] = [type]
+            type.interfaces.each do |i|
+              implementers = own_possible_types[i.graphql_name] ||= []
+              implementers << type
+              add_type(i, owner: type, late_types: late_types)
+            end
+          end
         end
       end
     end
@@ -1217,33 +1780,16 @@ module GraphQL
       end
     end
 
-    # Override this method to handle lazy objects in a custom way.
-    # @param value [Object] an instance of a class registered with {.lazy_resolve}
-    # @param ctx [GraphQL::Query::Context] the context for this query
-    # @return [Object] A GraphQL-ready (non-lazy) object
-    def self.sync_lazy(value)
-      if block_given?
-        # This was already hit by the instance, just give it back
-        yield(value)
-      else
-        # This was called directly on the class, hit the instance
-        # which has the lazy method map
-        self.graphql_definition.sync_lazy(value)
-      end
-    end
-
     # @see Schema.sync_lazy for a hook to override
     # @api private
     def sync_lazy(value)
-      self.class.sync_lazy(value) { |v|
-        lazy_method = lazy_method_name(v)
-        if lazy_method
-          synced_value = value.public_send(lazy_method)
-          sync_lazy(synced_value)
-        else
-          v
-        end
-      }
+      lazy_method = lazy_method_name(value)
+      if lazy_method
+        synced_value = value.public_send(lazy_method)
+        sync_lazy(synced_value)
+      else
+        value
+      end
     end
 
     protected