lighthouse-graphql 0.5.0 → 0.6.0

data/lib/lighthouse/directive_resolvers/throttle_resolver.rb

@@ -1,17 +1,35 @@
 # frozen_string_literal: true
 
+require 'active_support/duration'
+require 'active_support/notifications'
 require_relative 'base'
 
-# @throttle — rate-limit a field per client, as PHP Lighthouse's directive (and
-# Laravel's ThrottleRequests): at most `maxAttempts` calls every `decayMinutes`,
-# counted in Config.cache_store. A client is the signed-in user, else the
-# context's :remote_ip (Lighthouse::GraphQL::Controller sets it), else "guest".
-# Past the limit the field fails with "Rate limit for Query.x exceeded. Try
-# again later." Outermost: refused calls never reach @guard or the resolver.
+# @throttle — Rails' `rate_limit` on one field: at most `maxAttempts` calls (its
+# to:) every `decayMinutes` (its within:), counted as ActionController::RateLimiting
+# counts them, with its options:
+#
+#   by:      who the client is, as rate_limit's by: a path in the context, as
+#            @inject's ("current_user.id"); the client's IP by default.
+#   with:    a method of the controller to call past the limit, as rate_limit's
+#            with:. One that renders or redirects ends the request with its
+#            response, as a before_action that renders does; one that returns lets
+#            the call through. Without it, rate_limit's default: raise
+#            ActionController::TooManyRequests, which Rails answers with a 429
+#            (`head :too_many_requests` on a Rails without it, 7.2). Without Action
+#            Pack at all, the field fails: "Rate limit for Query.x exceeded. Try again later."
+#   name:    as rate_limit's: the field by default (Query.x). Fields, and the
+#            controller's own `rate_limit`, of the same name count together.
+#   prefix:  as rate_limit's scope: the controller's path by default.
+#
+# The count lives in the controller's cache_store (config.action_controller.cache_store,
+# Rails.cache unless set), under rate_limit's key, and a refused call is instrumented
+# as rate_limit's (rate_limit.action_controller). The controller concern puts the
+# controller in the context (:lighthouse_controller); outside one, the count lives in
+# Rails.cache, with no scope. Outermost: refused calls never reach @guard or the resolver.
 #
 #   type Mutation {
 #     login(email: String!, password: String!): User @throttle(maxAttempts: 5)
-#     search(term: String!): [Post!]! @throttle(name: "search", maxAttempts: 30, decayMinutes: 0.5)
+#     search(term: String!): [Post!]! @throttle(maxAttempts: 30, decayMinutes: 0.5, by: "current_user.id")
 #   }
 class Lighthouse::GraphQL::DirectiveResolvers::ThrottleDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
   def self.directive_name = 'throttle'
@@ -19,17 +37,21 @@ class Lighthouse::GraphQL::DirectiveResolvers::ThrottleDirectiveResolver < Light
   def self.definition
     <<~GRAPHQL.chomp
       """
-      Sets rate limit to access the field. Does the same as ThrottleRequests Laravel Middleware.
+      Sets rate limit to access the field, as Rails' rate_limit does for an action.
       """
       directive @throttle(
-        "A name shared by the fields that count together. Defaults to the field."
+        "As rate_limit's name: fields, and the controller's own rate_limit, of the same name count together. Defaults to the field."
         name: String
         "Maximum number of attempts in a specified time interval."
         maxAttempts: Int = 60
         "Time in minutes to reset attempts."
         decayMinutes: Float = 1.0
-        "Prefix to distinguish several field groups."
+        "As rate_limit's scope: what the count is shared across. Defaults to the controller's path."
         prefix: String
+        "As rate_limit's by: who the client is, a path in the context (\\"current_user.id\\"). Defaults to the client's IP."
+        by: String
+        "As rate_limit's with: the controller's method to call past the limit. Defaults to rate_limit's: a 429."
+        with: String
       ) on FIELD_DEFINITION
     GRAPHQL
   end
@@ -38,22 +60,24 @@ class Lighthouse::GraphQL::DirectiveResolvers::ThrottleDirectiveResolver < Light
     me = self
     inner = capture_inner(target_type_class)
     location = "#{target_type_class.graphql_name}.#{@field_def.name}"
-    bucket = "#{directive_arg('prefix')}#{directive_arg('name') || location}"
-    max_attempts = directive_arg('maxAttempts') || 60
-    decay = ((directive_arg('decayMinutes') || 1.0) * 60).ceil
+    limit = {
+      to: directive_arg('maxAttempts') || 60, within: ActiveSupport::Duration.build(((directive_arg('decayMinutes') || 1.0) * 60).ceil),
+      by: directive_arg('by'), with: directive_arg('with'), name: directive_arg('name') || location, scope: directive_arg('prefix')
+    }
 
     install(target_type_class, lambda do |obj, args, ctx|
-      me.hit!(bucket, ctx, max_attempts, decay, location)
+      me.hit!(limit, ctx, location)
       inner.call(obj, args, ctx)
     end)
   end
 
-  def hit!(bucket, ctx, max_attempts, decay, location)
-    key = "lighthouse:throttle:#{bucket}:#{client(ctx)}"
-    store = Lighthouse::GraphQL::Caching.store
-    self.class.warn_null_store(location) if store.is_a?(::ActiveSupport::Cache::NullStore)
-    attempts = store.increment(key, 1, expires_in: decay) || (store.write(key, 1, expires_in: decay) && 1)
-    raise ::GraphQL::ExecutionError, "Rate limit for #{location} exceeded. Try again later." if attempts > max_attempts
+  # ActionController::RateLimiting#rate_limiting, for one call of the field.
+  def hit!(limit, ctx, location)
+    controller = ctx[:lighthouse_controller]
+    key = { scope: limit[:scope] || controller&.controller_path, name: limit[:name], by: client(limit, ctx) }
+    cache_key = ['rate-limit', *key.values].compact.join(':')
+    count = increment(store(controller), cache_key, limit[:within], location)
+    refuse(controller, limit, location, key.merge(count: count, cache_key: cache_key)) if count && count > limit[:to]
   end
 
   # A :null_store keeps no count, so the limit never applies: say so, once per field.
@@ -61,17 +85,52 @@ class Lighthouse::GraphQL::DirectiveResolvers::ThrottleDirectiveResolver < Light
     @warned ||= Set.new
     return unless @warned.add?(location)
 
-    message = "Lighthouse: @throttle on #{location} counts nothing, as the cache store is a :null_store. Set Config.cache_store."
+    message = "Lighthouse: @throttle on #{location} counts nothing, as the cache store is a :null_store. " \
+              'Set config.action_controller.cache_store (or config.cache_store), as for Rails\' rate_limit.'
     defined?(Rails) && Rails.logger ? Rails.logger.warn(message) : warn(message)
   end
 
   private
 
-  def client(ctx)
-    user = Lighthouse::Support::Authorization.authenticated_user(ctx)
-    return "user:#{user.respond_to?(:id) ? user.id : user}" if user
+  # rate_limit's by: the value at `by`'s path in the context, else the client's IP.
+  def client(limit, ctx)
+    limit[:by] ? Lighthouse::Support::Arguments.dig(ctx, limit[:by]).first : ctx[:remote_ip]
+  end
+
+  # Where rate_limit counts: the controller's cache_store; Rails.cache outside one.
+  def store(controller)
+    controller.respond_to?(:cache_store) ? controller.cache_store : Lighthouse::GraphQL::Caching.store
+  end
+
+  # The count after this call. A store whose increment does not create the key
+  # (ActiveSupport before 7.1) starts it with a write.
+  def increment(store, key, within, location)
+    self.class.warn_null_store(location) if store.is_a?(::ActiveSupport::Cache::NullStore)
+    store.increment(key, 1, expires_in: within) || (store.write(key, 1, expires_in: within) && 1)
+  end
+
+  # Past the limit: instrumented as rate_limit's, around `with`, after which a
+  # response `with` performed ends the request, as a before_action's would.
+  def refuse(controller, limit, location, counted)
+    payload = { request: controller&.request, to: limit[:to], within: limit[:within], **counted }
+    ActiveSupport::Notifications.instrument('rate_limit.action_controller', payload) { limited(controller, limit[:with], location) }
+    raise Lighthouse::GraphQL::Controller::Performed if controller&.performed?
+  end
+
+  # The controller's `with` method, else rate_limit's default `with`.
+  def limited(controller, with, location)
+    return call_with(controller, with, location) if with && controller
+    raise ::ActionController::TooManyRequests if defined?(::ActionController::TooManyRequests)
+    return controller.head(:too_many_requests) if controller
+
+    raise ::GraphQL::ExecutionError, "Rate limit for #{location} exceeded. Try again later."
+  end
+
+  def call_with(controller, with, location)
+    unless controller.respond_to?(with, true)
+      raise Lighthouse::DefinitionError, "@throttle(with: \"#{with}\") on #{location}: #{controller.class} has no method #{with}."
+    end
 
-    ip = ctx.respond_to?(:[]) ? ctx[:remote_ip] : nil
-    ip ? "ip:#{ip}" : 'guest'
+    controller.send(with)
   end
 end

data/lib/lighthouse/directive_resolvers/type_method_resolver.rb

@@ -10,15 +10,18 @@ require_relative 'base'
 # `object` (the parent), `context`, the `dataload*` helpers, and the field's
 # arguments as snake_case keywords. A field with a resolving directive never
 # reaches it, and one whose name the class does not define is read off the
-# object as before. Not a directive: FieldResolverStack installs it on types
-# other than the root ones.
+# object as before. Not a directive: FieldResolverStack installs it, on the
+# root types too (Types::QueryType#latest_posts for Query.latestPosts, before
+# the conventional Resolvers::LatestPosts).
 class Lighthouse::GraphQL::DirectiveResolvers::TypeMethodResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
   # The class of the SDL type `type_name` (`Types::PostType` for `Post`) in
   # Config.namespaces[:types], when it includes Lighthouse::GraphQL::Type; nil
   # otherwise, so a type class that does not opt in is left alone. It must
   # inherit from the schema's base_types[:object] (in `bases`, ResolverBases)
-  # when one is given.
-  def self.type_class(type_name, bases = {})
+  # when one is given. A root type's class is the one it is built on (RootTypes).
+  def self.type_class(type_name, bases = {}, root_kind = nil)
+    return Lighthouse::GraphQL::RootTypes.type_class(root_kind, bases[:roots]) if root_kind
+
     klass = lookup(type_name)
     return unless klass
 
@@ -38,9 +41,12 @@ class Lighthouse::GraphQL::DirectiveResolvers::TypeMethodResolver < Lighthouse::
     name if klass.public_method_defined?(name) && !::GraphQL::Schema::Object.public_method_defined?(name)
   end
 
-  def initialize(field_def, type_def, method_name)
+  # `root_class`: the root type class the type is built on (RootTypes), used as
+  # it is; any other class is looked up by the type's name on each call.
+  def initialize(field_def, type_def, method_name, root_class = nil)
     super(field_def, type_def, nil)
     @method_name = method_name
+    @root_class = root_class
   end
 
   def define_resolver(target_type_class)
@@ -59,7 +65,7 @@ class Lighthouse::GraphQL::DirectiveResolvers::TypeMethodResolver < Lighthouse::
   # it no longer defines the method, the field is read as before. A parent that
   # is not a record of the type's @model is reported, and the field resolves to nil.
   def resolve_with_type(inner, obj, args, ctx)
-    klass = self.class.lookup(@type_def.graphql_name)
+    klass = @root_class || self.class.lookup(@type_def.graphql_name)
     return inner.call(obj, args, ctx) unless klass&.public_method_defined?(@method_name)
 
     model = Lighthouse::GraphQL::Directives::ModelDirective.declared_model(@type_def)

data/lib/lighthouse/directives/arguments/more_filters.rb

@@ -174,7 +174,7 @@ module Lighthouse::GraphQL::Directives::Arguments
           Typically, this option should only be used for root fields,
           as it may cause wrong results with batched relation queries.
           """
-          builder: Boolean! = false
+          builder: Boolean = false
         ) on ARGUMENT_DEFINITION | FIELD_DEFINITION
       GRAPHQL
     end

data/lib/lighthouse/field_resolver_stack.rb

@@ -55,20 +55,23 @@ module Lighthouse::GraphQL::FieldResolverStack
     [0, -> { resolver.define_resolver(type) }]
   end
 
-  # What resolves a field with no resolving directive: the conventional class
-  # of a root field, or the method of the type's class. nil: the default reader.
+  # What resolves a field with no resolving directive: the method of the
+  # type's class (Types::QueryType#latest_posts too, as in graphql-ruby), else
+  # for a Query or Mutation field the conventional class. nil: the default reader.
   def own_step(type, field_def, root_kind, bases, type_class)
-    return convention_step(type, field_def, root_kind, bases) if root_kind
+    return convention_step(type, field_def, root_kind, bases) if root_kind == :subscriptions
 
-    type_method_step(type, field_def, type_class) if type_class
+    step = type_method_step(type, field_def, type_class, root: !root_kind.nil?) if type_class
+    step || (convention_step(type, field_def, root_kind, bases) if root_kind)
   end
 
   # Nothing to install when the class does not define the field's method: the
   # field is read off the object.
-  def type_method_step(type, field_def, type_class)
+  # `root`: the class is the root type's, which the type is built on, not one found by name.
+  def type_method_step(type, field_def, type_class, root: false)
     resolver = Lighthouse::GraphQL::DirectiveResolvers::TypeMethodResolver
     method_name = resolver.method_for(type_class, field_def)
-    [0, -> { resolver.new(field_def, type, method_name).define_resolver(type) }] if method_name
+    [0, -> { resolver.new(field_def, type, method_name, root ? type_class : nil).define_resolver(type) }] if method_name
   end
 
   # An explicit @validator on the field already validates its arguments.

data/lib/lighthouse/global_id.rb

@@ -7,6 +7,12 @@ require 'base64'
 # Config.global_id takes another object with `encode(type, id)` and
 # `decode(global_id)` -> [type, id], as PHP Lighthouse lets the GlobalId
 # contract be rebound.
+#
+# A schema that implements graphql-ruby's Relay ids, `id_from_object` and
+# `object_from_id` (graphql-ruby's install writes them, on Rails' GlobalID),
+# has one kind of global id: @globalId encodes an object's own id with
+# `id_from_object`, and decodes with `object_from_id`, as graphql-ruby's
+# Query.node and Node's `id` do.
 module Lighthouse::GraphQL::GlobalId
   module_function
 
@@ -20,12 +26,32 @@ module Lighthouse::GraphQL::GlobalId
     []
   end
 
-  # [type, id] for a global id a client sent, through Config.global_id; a
+  # [type, id] for a global id a client sent, through the schema's
+  # object_from_id (schema_ids?) or Config.global_id; a
   # GraphQL::ExecutionError when it is not one.
-  def decode!(global_id)
-    type, id = Lighthouse::Config.global_id.decode(global_id)
+  def decode!(global_id, context = nil)
+    type, id = schema_ids?(context&.schema) ? decode_object(global_id, context) : Lighthouse::Config.global_id.decode(global_id)
     return [type, id] if type.present? && !id.nil?
 
     raise ::GraphQL::ExecutionError, "#{global_id.inspect} is not a valid global id."
   end
+
+  # The global id of `object`'s own id (`id`, what a field of `type` resolved)
+  # through the schema's id_from_object (schema_ids?); nil for anything else.
+  def encode_field(type, object, id, context)
+    return unless schema_ids?(context&.schema) && object.respond_to?(:id) && object.id.to_s == id.to_s
+
+    context.schema.id_from_object(object, type, context)
+  end
+
+  # Does `schema` define graphql-ruby's object_from_id (GraphQL::Schema's own raises)?
+  def schema_ids?(schema)
+    schema.respond_to?(:object_from_id) && schema.method(:object_from_id).owner != ::GraphQL::Schema.singleton_class
+  end
+
+  # [type, id] of the object the schema's object_from_id finds.
+  def decode_object(global_id, context)
+    object = context.schema.object_from_id(global_id, context)
+    object.nil? ? [] : [object.class.name.demodulize, object.id]
+  end
 end

data/lib/lighthouse/graphql/version.rb

@@ -2,6 +2,6 @@
 
 module Lighthouse
   module GraphQL
-    VERSION = '0.5.0'
+    VERSION = '0.6.0'
   end
 end

data/lib/lighthouse/graphql_ruby_patches.rb

@@ -15,4 +15,49 @@ module Lighthouse::GraphQL
   # skip the fix rather than fail to load (explicit nulls then fail as before).
   builder = ::GraphQL::Schema::BuildFromDefinition.const_get(:Builder) if ::GraphQL::Schema::BuildFromDefinition.const_defined?(:Builder)
   builder.prepend(NullDirectiveArguments) if builder && (builder.method_defined?(:args_to_kwargs) || builder.private_method_defined?(:args_to_kwargs))
+
+  # graphql-ruby builds every SDL object type on base_types[:object], and every
+  # interface from base_types[:interface]. RootTypes builds a root type on the
+  # app's code-first one (Types::QueryType) instead, and takes the app's Node
+  # interface (Types::NodeType) as the SDL's Node.
+  module RootTypeBuilder
+    def build_object_type(definition, type_resolver, base_type)
+      root = Lighthouse::GraphQL::RootTypes.base_for(definition.name)
+      return super unless root
+
+      super(Lighthouse::GraphQL::RootTypes.definition_on(definition, root), type_resolver, root)
+    end
+
+    def build_interface_type(definition, type_resolver, base_type)
+      Lighthouse::GraphQL::RootTypes.base_for(definition.name) || super
+    end
+  end
+
+  # As above, a graphql-ruby release that reshapes the builder skips the hook:
+  # root types are then built on base_types[:object], as before.
+  if builder && %i[build_object_type build_interface_type].all? { |name| builder.method_defined?(name) || builder.private_method_defined?(name) }
+    builder.prepend(RootTypeBuilder)
+  end
+
+  # The app's schema class inherits Lighthouse's (`class AppSchema <
+  # get_schema(...)`), so its Subscription root type is the parent's. A
+  # subscriptions backend the subclass `use`s (ActionCableSubscriptions) then
+  # finds no root type of the subclass's own, and graphql-ruby adds its
+  # subscription extension to no field. Look the root type up through the
+  # parent too. Extended onto the schemas Lighthouse builds (SchemaGenerator).
+  module InheritedSubscriptionRoot
+    def add_subscription_extension_if_necessary
+      return super if @subscription_object.is_a?(Class) || !defined?(::GraphQL::Subscriptions::DefaultSubscriptionResolveExtension)
+      return unless inherited_subscription_root_pending?
+
+      @subscription_extension_added = true
+      extension = ::GraphQL::Subscriptions::DefaultSubscriptionResolveExtension
+      subscription.all_field_definitions.each { |field| field.extension(extension) unless field.extensions.any?(extension) }
+    end
+
+    # A backend, a root type from the parent, and no extension added yet.
+    def inherited_subscription_root_pending?
+      !defined?(@subscription_extension_added) && subscription.is_a?(Class) && !subscriptions.nil?
+    end
+  end
 end

data/lib/lighthouse/rb_lighthouse.rb

@@ -48,6 +48,7 @@ require_relative 'namespaces'
   events/execution_trace
   events/schema_build
   resolver_bases
+  root_types
   schema_generator
   schema_cache
   persisted_queries

data/lib/lighthouse/resolver_bases.rb

@@ -18,6 +18,11 @@
 #   it is first used, so none misses what the base shares;
 # - for subscriptions, also resolves a Subscription field that has no class of
 #   its own, instead of Lighthouse::GraphQL::Subscription::Default.
+#
+# The code-first types graphql-ruby's install writes are bases too (RootTypes):
+# `query_type:` / `mutation_type:` / `subscription_type:` (Types::QueryType, ...)
+# are what the SDL's root types are built on, so their `field`s are the
+# schema's too, and `node:` (Types::NodeType) is the SDL's Node interface.
 module Lighthouse::GraphQL::ResolverBases
   # base_types key => the graphql-ruby class the base must inherit from.
   GRAPHQL_CLASSES = {
@@ -35,19 +40,28 @@ module Lighthouse::GraphQL::ResolverBases
   # (Types::PostType, Types::DateTimeType, ...) inherit from too.
   TYPE_KINDS = %i[object union interface scalar].freeze
 
-  # Take the three keys out of opts[:base_types] (the caller's Hash is not
+  # Take Lighthouse's keys out of opts[:base_types] (the caller's Hash is not
   # changed) and return { root kind => base class } for those given, plus
-  # :types => { kind => base } for graphql-ruby's own, which stay in opts.
+  # :types => { kind => base } for graphql-ruby's own, which stay in opts, and
+  # :roots => { query_type: ..., node: ... } for the code-first types (RootTypes).
   def extract!(opts)
     base_types = opts[:base_types]
     return {} unless base_types.is_a?(Hash)
 
     given = base_types.slice(*GRAPHQL_CLASSES.keys).compact
-    opts[:base_types] = base_types.except(*GRAPHQL_CLASSES.keys)
+    opts[:base_types] = base_types.except(*GRAPHQL_CLASSES.keys, *Lighthouse::GraphQL::RootTypes::KEYS)
     given.each { |key, klass| validate!(key, klass) }
     bases = KEYS.filter_map { |kind, key| [kind, given[key]] if given[key] }.to_h
     type_bases = base_types.slice(*TYPE_KINDS).compact
-    type_bases.empty? ? bases : bases.merge(types: type_bases)
+    bases = bases.merge(types: type_bases) unless type_bases.empty?
+    with_roots(bases, base_types)
+  end
+
+  # `bases` with the code-first root types given, validated, under :roots.
+  def with_roots(bases, base_types)
+    roots = base_types.slice(*Lighthouse::GraphQL::RootTypes::KEYS).compact
+    roots.each { |key, type| Lighthouse::GraphQL::RootTypes.validate!(key, type) }
+    roots.empty? ? bases : bases.merge(roots: roots)
   end
 
   def validate!(key, klass)

data/lib/lighthouse/resolver_dispatch.rb

@@ -32,7 +32,22 @@ module Lighthouse::GraphQL::ResolverDispatch
     kwargs = Lighthouse::Support::Arguments.prepare(info.field, info.arguments, info.context)
     instance = Lighthouse::GraphQL::ResolveInfo.attach(klass.new(object: info.object, context: info.context, field: info.field), info)
     instance.define_singleton_method(:resolve) { |**values| public_send(method, **values) } if method
-    instance.resolve_with_support(**kwargs)
+    single_input?(instance, kwargs) ? instance.resolve_with_support(**kwargs) : resolve_as_mutation(instance, kwargs)
+  end
+
+  # graphql-ruby's RelayClassicMutation (the base mutation its install writes)
+  # takes one `input:` argument. A field that declares its arguments one by one
+  # calls it as a plain GraphQL::Schema::Mutation, with them as keywords: past
+  # HasSingleInputArgument's unwrapping of `input:`, and its authorization of
+  # the arguments of `input:`.
+  def single_input?(instance, kwargs)
+    !instance.is_a?(::GraphQL::Schema::HasSingleInputArgument) || kwargs.key?(:input)
+  end
+
+  def resolve_as_mutation(instance, kwargs)
+    instance.define_singleton_method(:authorize_arguments, ::GraphQL::Schema::Resolver.instance_method(:authorize_arguments))
+    instance.singleton_class.send(:private, :authorize_arguments)
+    ::GraphQL::Schema::Mutation.instance_method(:resolve_with_support).bind_call(instance, **kwargs)
   end
 
   # The class itself when it answers `name` as a class method, else an instance.

data/lib/lighthouse/root_types.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+# The code-first types graphql-ruby's install writes, which a schema builds on:
+#
+#   base_types: { query_type: Types::QueryType, mutation_type: Types::MutationType,
+#                 subscription_type: Types::SubscriptionType, node: Types::NodeType }
+#
+# - A root type given is what the SDL's root type of that kind is built on,
+#   instead of base_types[:object]: the SDL's `type Query` is a subclass of
+#   Types::QueryType, so the `field`s the class declares (graphql-ruby's
+#   `node` / `nodes`, what `graphql:mutation` adds to Types::MutationType)
+#   are the schema's too, beside the SDL's, and resolve as in graphql-ruby. An
+#   SDL field of the same name wins. With no such root type in the SDL, the
+#   class itself is the root, once it declares a field.
+# - `node:` is the SDL's Node interface: `interface Node`, which @node adds and
+#   `implements Node` names, is that module, so graphql-ruby's Relay
+#   (Query.node / nodes, the schema's id_from_object / object_from_id) and the
+#   SDL's @node types share one Node. The `node` field @node adds to Query then
+#   gives way to the root type class's own.
+#
+# graphql-ruby's builder knows one base per kind, so the hook into it is a
+# patch (graphql_ruby_patches.rb), which reads the bases of the build in
+# progress from here.
+module Lighthouse::GraphQL::RootTypes
+  KEYS = %i[query_type mutation_type subscription_type node].freeze
+
+  ROOTS = { query_type: :query, mutation_type: :mutation, subscription_type: :subscription }.freeze
+
+  # The resolver of the `node` field @node adds to Query.
+  NODE_RESOLVER = 'Lighthouse::GraphQL::NodeRegistry@resolve'
+
+  module_function
+
+  def validate!(key, type)
+    valid = key == :node ? Lighthouse::GraphQL::Type.kind_of(type) == :interface : type.is_a?(Class) && type < ::GraphQL::Schema::Object
+    return if valid
+
+    expected = key == :node ? 'a module including GraphQL::Schema::Interface' : 'a subclass of GraphQL::Schema::Object'
+    raise Lighthouse::DefinitionError, "base_types[:#{key}] must be #{expected}, not #{type.inspect}."
+  end
+
+  # The root type class the SDL's root type of `root_kind` (:queries,
+  # :mutations) is built on, when it is Lighthouse's (Lighthouse::GraphQL::Type):
+  # its methods resolve the root fields of their name.
+  def type_class(root_kind, roots)
+    klass = roots&.[]({ queries: :query_type, mutations: :mutation_type }[root_kind])
+    klass if klass&.include?(Lighthouse::GraphQL::Type)
+  end
+
+  # Run the block (the build of `document`) with `roots` as the bases of the
+  # types they name.
+  def with(document, roots)
+    previous = Thread.current[:lighthouse_root_types]
+    Thread.current[:lighthouse_root_types] = by_type_name(document, roots || {})
+    yield
+  ensure
+    Thread.current[:lighthouse_root_types] = previous
+  end
+
+  # The class an SDL type of `name` is built on, or nil.
+  def base_for(name)
+    Thread.current[:lighthouse_root_types]&.[](name)
+  end
+
+  # `definition` without the fields `base` declares itself that @node added.
+  def definition_on(definition, base)
+    names = field_names(base)
+    fields = definition.fields.reject { |field| names.include?(field.name) && added_by_node?(field) }
+    fields.size == definition.fields.size ? definition : definition.merge(fields: fields)
+  end
+
+  # The names of the fields a class and its ancestors declare. Not `fields`,
+  # which warns about a type with none (graphql-ruby's install leaves
+  # Types::MutationType empty once its example field goes).
+  def field_names(type)
+    type.ancestors.select { |ancestor| ancestor.respond_to?(:own_fields) }.flat_map { |ancestor| ancestor.own_fields.keys }.uniq
+  end
+
+  # The schema the block builds from `document`, with `roots` as the bases of
+  # the types they name; then the root type classes the SDL has no type for,
+  # and the subscriptions backend an app schema class `use`s (graphql_ruby_patches.rb).
+  def build(document, roots, &block)
+    schema = with(document, roots, &block)
+    apply_missing(schema, roots)
+    schema.extend(Lighthouse::GraphQL::InheritedSubscriptionRoot) if schema.respond_to?(:add_subscription_extension_if_necessary, true)
+    schema
+  end
+
+  # A root type class the SDL has no type for is the root itself, once it
+  # declares a field (graphql-ruby's install writes them with an example one).
+  def apply_missing(schema, roots)
+    ROOTS.each do |key, root|
+      type = roots&.[](key)
+      next if type.nil? || schema.public_send(root) || field_names(type).empty?
+
+      schema.public_send(root, type)
+    end
+  end
+
+  def by_type_name(document, roots)
+    names = root_names(document)
+    mapped = ROOTS.each_with_object({}) { |(key, root), out| out[names[root]] = roots[key] if roots[key] }
+    roots[:node] ? mapped.merge('Node' => roots[:node]) : mapped
+  end
+
+  # { query: 'Query', ... }, as the document's `schema { }` names them.
+  def root_names(document)
+    schema = document.definitions.find { |definition| definition.is_a?(::GraphQL::Language::Nodes::SchemaDefinition) }
+    { query: schema&.query || 'Query', mutation: schema&.mutation || 'Mutation', subscription: schema&.subscription || 'Subscription' }
+  end
+
+  def added_by_node?(field)
+    field.directives.any? do |directive|
+      directive.name == 'field' && Lighthouse::Support::DirectiveArgs.literal(directive, 'resolver') == NODE_RESOLVER
+    end
+  end
+end

data/lib/lighthouse/schema_generator.rb

@@ -47,7 +47,7 @@ module Lighthouse::GraphQL::SchemaGenerator
     impl = default_implementation
     # base_types' resolver / mutation / subscription are Lighthouse's, not graphql-ruby's.
     bases = Lighthouse::GraphQL::ResolverBases.extract!(opts)
-    schema = from_document(document, impl, opts)
+    schema = Lighthouse::GraphQL::RootTypes.build(document, bases[:roots]) { from_document(document, impl, opts) }
 
     delegate_to_federation_sdl(schema)
     Lighthouse::GraphQL::GeneratedResolvers.install_dispatcher(schema)
@@ -140,8 +140,9 @@ module Lighthouse::GraphQL::SchemaGenerator
       # Apollo Federation helper can detect entities and add _entities.
       Lighthouse::GraphQL::FederationDirectives.apply(type)
       root_kind = root_kinds[type.graphql_name]
-      type_class = root_kind ? nil : Lighthouse::GraphQL::DirectiveResolvers::TypeMethodResolver.type_class(type.graphql_name, bases)
-      type.fields.each_value { |field_def| process_field(type, field_def, root_kind, bases, type_class) }
+      type_class = Lighthouse::GraphQL::DirectiveResolvers::TypeMethodResolver.type_class(type.graphql_name, bases, root_kind)
+      # A field a code-first base declares (RootTypes) resolves as graphql-ruby resolves it.
+      type.fields.each_value { |field_def| process_field(type, field_def, root_kind, bases, type_class) if field_def.owner == type }
     end
 
     # @complexity, and paginated fields, give graphql-ruby's complexity analysis their cost.

data/lib/lighthouse/upload.rb

@@ -13,11 +13,13 @@ class Lighthouse::GraphQL::Upload < GraphQL::Schema::Scalar
   def self.coerce_input(value, _context)
     return value if file?(value)
 
-    raise ::GraphQL::CoercionError, 'Could not get uploaded file, be sure to conform to the GraphQL multipart request specification.'
+    raise ::GraphQL::CoercionError,
+          'Could not get uploaded file, be sure to conform to GraphQL multipart request specification: ' \
+          "https://github.com/jaydenseric/graphql-multipart-request-spec. Instead got: #{value.inspect}."
   end
 
   def self.coerce_result(_value, _context)
-    raise ::GraphQL::Error, 'The Upload scalar can only be used as an argument, not returned.'
+    raise ::GraphQL::Error, '"Upload" cannot be serialized, it can only be used as an argument.'
   end
 
   def self.file?(value)