lighthouse-graphql 0.3.0 → 0.4.0

data/lib/generators/lighthouse/install/templates/schema.rb.tt

@@ -2,9 +2,21 @@
 
 # Executable schema built by Lighthouse from the SDL in <%= sdl_folder %>/. The
 # Dataloader batches relationship loads (@hasMany, @belongsTo, ...) to avoid N+1.
+# base_types names the base classes: every class a Query, Mutation or Subscription
+# field resolves to must inherit from its kind's, and a Subscription field with no
+# class of its own resolves with the subscription one.
 <%= schema_name %> = Lighthouse::GraphQL::RbLightHouse.get_schema(
   options: {
-    using: { GraphQL::Dataloader => {} }
-    # base_types: { object: Types::BaseObject } # your graphql-ruby base classes
+    using: { GraphQL::Dataloader => {} },
+    base_types: {
+      resolver: <%= base_class_constant(:queries) %>,
+      mutation: <%= base_class_constant(:mutations) %>,
+      subscription: <%= base_class_constant(:subscriptions) %>
+      # object: Types::BaseObject, ... # graphql-ruby's base classes of the SDL's types
+    }
   }
 )
+
+# Refuse expensive queries before they run (see the gem's docs/security.md):
+# <%= schema_name %>.max_complexity(300)
+# <%= schema_name %>.max_depth(12)

data/lib/generators/lighthouse/mutation_generator.rb

@@ -2,10 +2,11 @@
 
 require_relative 'class_generator'
 
-# `rails generate lighthouse:mutation PublishPost` — a GraphQL::Schema::Mutation
-# that `Mutation.publishPost` resolves to by convention.
+# `rails generate lighthouse:mutation PublishPost` — the class (a
+# Mutations::BaseMutation, so a GraphQL::Schema::Mutation) that `Mutation.publishPost`
+# resolves to by convention.
 class Lighthouse::Generators::MutationGenerator < Lighthouse::Generators::ClassGenerator
-  desc 'Generate a mutation class (GraphQL::Schema::Mutation) in app/graphql/mutations.'
+  desc 'Generate the class of a Mutation field (a Mutations::BaseMutation) in app/graphql/mutations.'
 
   private
 
@@ -16,7 +17,7 @@ class Lighthouse::Generators::MutationGenerator < Lighthouse::Generators::ClassG
       # Resolves Mutation.#{class_basename.camelize(:lower)}. Keyword arguments are the field's
       # arguments in snake_case; `object` and `context` are available. Raise
       # GraphQL::ExecutionError for failures the client should see.
-      class #{class_basename} < GraphQL::Schema::Mutation
+      class #{class_basename} < #{superclass_name}
         def resolve(**args)
           raise NotImplementedError
         end

data/lib/generators/lighthouse/query_generator.rb

@@ -2,10 +2,11 @@
 
 require_relative 'class_generator'
 
-# `rails generate lighthouse:query LatestPosts` — a GraphQL::Schema::Resolver
-# that `Query.latestPosts` resolves to by convention.
+# `rails generate lighthouse:query LatestPosts` — the resolver (a
+# Resolvers::BaseResolver, so a GraphQL::Schema::Resolver) that `Query.latestPosts`
+# resolves to by convention.
 class Lighthouse::Generators::QueryGenerator < Lighthouse::Generators::ClassGenerator
-  desc 'Generate a query class (GraphQL::Schema::Resolver) in app/graphql/queries.'
+  desc 'Generate the resolver of a Query field (a Resolvers::BaseResolver) in app/graphql/resolvers.'
 
   private
 
@@ -15,7 +16,7 @@ class Lighthouse::Generators::QueryGenerator < Lighthouse::Generators::ClassGene
     <<~RUBY
       # Resolves Query.#{class_basename.camelize(:lower)}. Keyword arguments are the field's
       # arguments in snake_case; `object` and `context` are available.
-      class #{class_basename} < GraphQL::Schema::Resolver
+      class #{class_basename} < #{superclass_name}
         def resolve(**args)
           raise NotImplementedError
         end

data/lib/generators/lighthouse/subscription_generator.rb

@@ -2,22 +2,27 @@
 
 require_relative 'class_generator'
 
-# `rails generate lighthouse:subscription PostUpdated` — a
-# GraphQL::Schema::Subscription that `Subscription.postUpdated` resolves to by
-# convention. With `--lighthouse`, the class also includes
-# Lighthouse::GraphQL::Subscription (PHP Lighthouse's authorize?/filter?/resolve_payload hooks).
+# `rails generate lighthouse:subscription PostUpdated` — the class (a
+# Subscriptions::BaseSubscription, so a GraphQL::Schema::Subscription) that
+# `Subscription.postUpdated` resolves to by convention. The base Lighthouse writes
+# includes Lighthouse::GraphQL::Subscription, so the class gets PHP Lighthouse's
+# authorize?/filter?/resolve_payload hooks; under a base without the concern, it
+# gets graphql-ruby's authorized?/update instead.
 class Lighthouse::Generators::SubscriptionGenerator < Lighthouse::Generators::ClassGenerator
-  desc 'Generate a subscription class (GraphQL::Schema::Subscription) in app/graphql/subscriptions.'
-
-  class_option :lighthouse, type: :boolean, default: false,
-                            desc: "Include Lighthouse::GraphQL::Subscription: PHP Lighthouse's authorize?/filter?/resolve_payload hooks"
+  desc 'Generate the class of a Subscription field (a Subscriptions::BaseSubscription) in app/graphql/subscriptions.'
 
   private
 
   def kind = :subscriptions
 
   def body
-    options[:lighthouse] ? lighthouse_body : plain_body
+    lighthouse_base? ? lighthouse_body : plain_body
+  end
+
+  # Does the namespace's base class include Lighthouse's concern?
+  def lighthouse_base?
+    path = File.join(destination_root, base_class_path(kind, namespace_name))
+    File.exist?(path) && File.read(path).include?('Lighthouse::GraphQL::Subscription')
   end
 
   def plain_body
@@ -25,7 +30,7 @@ class Lighthouse::Generators::SubscriptionGenerator < Lighthouse::Generators::Cl
       # Resolves Subscription.#{field_name}. Keyword arguments are the field's arguments in
       # snake_case; `object` and `context` are available. `context` is the subscriber's:
       # graphql-ruby stores it with the subscription and replays it for every update.
-      class #{class_basename} < GraphQL::Schema::Subscription
+      class #{class_basename} < #{superclass_name}
         # Runs for the subscription request and again for every update. Raise a
         # GraphQL::ExecutionError to refuse with a message (false refuses silently).
         def authorized?(**args)
@@ -62,12 +67,12 @@ class Lighthouse::Generators::SubscriptionGenerator < Lighthouse::Generators::Cl
 
   def lighthouse_body
     <<~RUBY
-      # Resolves Subscription.#{field_name}. A graphql-ruby subscription with PHP Lighthouse's
-      # hooks: every subscriber of the field gets every broadcast, and `filter?` decides.
-      # All hooks are optional; `object` and `context` (the subscriber's) are available.
-      class #{class_basename} < GraphQL::Schema::Subscription
-        include Lighthouse::GraphQL::Subscription
-
+      # Resolves Subscription.#{field_name}. #{superclass_name} includes Lighthouse::GraphQL::Subscription,
+      # PHP Lighthouse's hooks: every subscriber of the field gets every broadcast, and
+      # `filter?` decides. All hooks are optional; `object` and `context` (the
+      # subscriber's) are available. graphql-ruby's own `authorized?` or `update`,
+      # defined here, win over them.
+      class #{class_basename} < #{superclass_name}
         # May this client subscribe? Keyword arguments are the field's arguments.
         def authorize?(**args)
           true

data/lib/lighthouse/complexity.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+# @complexity — what a field costs in a query's complexity score, the score
+# graphql-ruby checks against the schema's `max_complexity` before it runs a
+# query (GraphQL::Analysis::MaxQueryComplexity), as PHP Lighthouse does with
+# webonyx's QueryComplexity rule.
+#
+# Lighthouse scores nothing itself: it gives fields their cost through
+# graphql-ruby's `Field#complexity_for` hook, and graphql-ruby's analyzers add
+# the costs up. A field costs:
+#
+# - With a bare @complexity, and on every paginated field (@paginate, and the
+#   relationship directives given `type:`), 1 plus its selection's cost once per
+#   item asked for (`first`, which defaults to the page size).
+# - With @complexity(resolver: "Name"), the `complexity` the analyzer class
+#   declares when it includes Lighthouse::GraphQL::ComplexityAnalyzer; else as
+#   with a bare @complexity.
+# - When a GraphQL::Schema::Resolver class resolves it (by convention, as
+#   `Resolvers::Search` resolves `Query.search`, or through @field), the
+#   `complexity` that class declares, as graphql-ruby gives `field ..., resolver:`.
+# - Otherwise graphql-ruby's default: 1 plus its selection's cost.
+#
+# `resolver:` names a GraphQL::Analysis::Analyzer subclass, looked up in
+# Config.namespaces[:analyzers] (`Analyzers::Name`). Lighthouse installs it on
+# the schema, as graphql-ruby's `query_analyzer Analyzers::Name` would, so it
+# runs on every query.
+#
+# Analyzer scores each query for BuildExtensionsResponse#query_complexity while
+# something listens to that event.
+module Lighthouse::GraphQL::Complexity
+  DEFINITION = 'directive @complexity(resolver: String) on FIELD_DEFINITION'
+
+  CONTEXT_KEY = :lighthouse_query_complexity
+
+  module_function
+
+  # Give the schema's fields their cost and install the analyzers @complexity
+  # names (see above). `root_kinds` maps the root types' names to :queries /
+  # :mutations / :subscriptions.
+  def apply(schema, root_kinds = {})
+    schema.types.each_value do |type|
+      next unless type.kind.object? || type.kind.interface?
+
+      type.fields.each_value do |field|
+        calculator = calculator_for(schema, type, field, root_kinds[type.graphql_name])
+        install(field, calculator) if calculator
+      end
+    end
+    schema
+  end
+
+  # A query's score, once Analyzer has run on it; nil otherwise.
+  def query_complexity(query)
+    query.context[CONTEXT_KEY]
+  end
+
+  # graphql-ruby asks the field for its cost through `complexity_for`, which wins
+  # over a number or proc in `complexity` and over its own scaling of connections.
+  def install(field, calculator)
+    field.define_singleton_method(:complexity_for) do |child_complexity:, query:, lookahead:|
+      calculator.call(query.context, lookahead.arguments, child_complexity)
+    end
+  end
+
+  # A callable (context, args, child_complexity) -> cost, or nil to leave the
+  # field to graphql-ruby.
+  def calculator_for(schema, type, field, kind)
+    return unless field.ast_node
+
+    directives = field.ast_node.directives || []
+    directive = directives.find { |d| d.name == 'complexity' }
+    return directive_calculator(schema, directive, "#{type.graphql_name}.#{field.name}") if directive
+    return method(:per_item) if paginated?(directives)
+
+    resolver_class_calculator(field, directives, kind)
+  end
+
+  def directive_calculator(schema, directive, path)
+    name = Lighthouse::Support::DirectiveArgs.literal(directive, 'resolver')
+    return method(:per_item) if name.nil? || name.to_s.strip.empty?
+
+    analyzer = analyzer_class(name.to_s, path)
+    schema.query_analyzer(analyzer) unless schema.query_analyzers.include?(analyzer)
+    return method(:per_item) unless analyzer.include?(Lighthouse::GraphQL::ComplexityAnalyzer)
+
+    lambda do |context, args, child_complexity|
+      cost = analyzer.complexity
+      cost.nil? ? per_item(context, args, child_complexity) : own_cost(cost, context, args, child_complexity)
+    end
+  end
+
+  def analyzer_class(name, path)
+    namespaces = Lighthouse::Config.namespaces[:analyzers]
+    klass = Lighthouse::Support::ModelResolver.constantize(name, namespaces: namespaces)
+    unless klass
+      raise Lighthouse::DefinitionError,
+            "@complexity on #{path}: no analyzer #{name} (looked up in #{Array(namespaces).join(', ')})"
+    end
+    return klass if klass.is_a?(Class) && klass < ::GraphQL::Analysis::Analyzer
+
+    raise Lighthouse::DefinitionError, "@complexity on #{path}: #{klass} must inherit from GraphQL::Analysis::Analyzer"
+  end
+
+  # The field and its selection once per item asked for: PHP Lighthouse's
+  # default, and what a page of `first` items costs.
+  def per_item(_context, args, child_complexity)
+    1 + (child_complexity * (args[:first] || 1))
+  end
+
+  # graphql-ruby's default cost: the field, plus its selection.
+  def default_cost(child_complexity)
+    1 + child_complexity
+  end
+
+  # A cost as graphql-ruby's Field#complexity takes it: a number, added to the
+  # selection's, or a proc (context, args, child_complexity).
+  def own_cost(cost, context, args, child_complexity)
+    cost.respond_to?(:call) ? cost.call(context, args, child_complexity) : cost + child_complexity
+  end
+
+  def paginated?(directives)
+    relations = Lighthouse::GraphQL::Directives::PaginationManipulator::RELATION_DIRECTIVES
+    directives.any? do |d|
+      d.name == 'paginate' || (relations.include?(d.name) && Lighthouse::Support::DirectiveArgs.literal(d, 'type'))
+    end
+  end
+
+  # The `complexity` of the GraphQL::Schema::Resolver class that resolves the
+  # field, by convention or through @field; nil when no such class can. The
+  # class is looked up when a query is scored, so code reloading works.
+  def resolver_class_calculator(field, directives, kind)
+    lookup = resolver_class_lookup(field, directives, kind)
+    return unless lookup
+
+    lambda do |context, args, child_complexity|
+      klass = lookup.call
+      next default_cost(child_complexity) unless Lighthouse::GraphQL::ResolverDispatch.graphql_resolver?(klass)
+
+      own_cost(klass.complexity, context, args, child_complexity)
+    end
+  end
+
+  def resolver_class_lookup(field, directives, kind)
+    directive = directives.find { |d| d.name == 'field' }
+    return field_class_lookup(directive, kind) if directive
+    return unless %i[queries mutations].include?(kind) && !Lighthouse::GraphQL::FieldResolverStack.resolving_directive?(directives)
+
+    class_name = Lighthouse::GraphQL::DirectiveResolvers::ConventionResolver.class_name_for(field)
+    -> { Lighthouse::Support::ModelResolver.constantize(class_name, namespaces: Lighthouse::Config.namespaces[kind], fallback: false) }
+  end
+
+  # The class @field names, looked up as @field looks it up.
+  def field_class_lookup(directive, kind)
+    class_name = %w[resolver class].filter_map { |name| Lighthouse::Support::DirectiveArgs.literal(directive, name) }.first
+    return unless class_name
+
+    namespaces = kind ? Lighthouse::Config.namespaces[kind] : Lighthouse::Config.resolver_namespaces
+    -> { Lighthouse::Support::ModelResolver.constantize(class_name, namespaces: namespaces) }
+  end
+
+  # Scores each query as graphql-ruby's MaxQueryComplexity scores it against
+  # `max_complexity`, for BuildExtensionsResponse#query_complexity. Runs only
+  # while something listens to that event.
+  class Analyzer < ::GraphQL::Analysis::QueryComplexity
+    def analyze?
+      Lighthouse::Events.listening?(Lighthouse::Events::BuildExtensionsResponse)
+    end
+
+    def result
+      query.context[CONTEXT_KEY] = max_possible_complexity
+      nil
+    end
+  end
+end

data/lib/lighthouse/complexity_analyzer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+# A concern for a graphql-ruby analyzer that @complexity(resolver:) names. Its
+# one method, `complexity`, gives the fields naming the class their cost, as
+# graphql-ruby's `complexity` gives a field or a GraphQL::Schema::Resolver one:
+#
+#   class Analyzers::TagPostsComplexity < GraphQL::Analysis::QueryComplexity
+#     include Lighthouse::GraphQL::ComplexityAnalyzer
+#
+#     complexity ->(_context, _args, child_complexity) { 1 + (child_complexity * 25) }
+#   end
+#
+# A number is added to the cost of the field's selection; a proc is called with
+# (context, args, child_complexity) and returns the whole cost. Without
+# `complexity`, the field costs what a bare @complexity gives.
+#
+# The class stays an analyzer, installed on the schema like any class @complexity
+# names: a `result` of its own runs on every query, in graphql-ruby's analysis.
+# Without one it only gives costs, and graphql-ruby skips it.
+module Lighthouse::GraphQL::ComplexityAnalyzer
+  extend ActiveSupport::Concern
+
+  class_methods do
+    # Set the cost (a number or a proc taking context, args and child_complexity),
+    # or read it: the class's own, else its superclass's, else nil.
+    def complexity(new_complexity = nil)
+      return inherited_complexity if new_complexity.nil?
+
+      unless new_complexity.is_a?(Numeric) || (new_complexity.is_a?(Proc) && new_complexity.parameters.size == 3)
+        raise ArgumentError, "#{name}.complexity takes a number or a proc of (context, args, child_complexity), " \
+                             "got #{new_complexity.inspect}"
+      end
+
+      @complexity = new_complexity
+    end
+
+    private
+
+    def inherited_complexity
+      return @complexity if defined?(@complexity)
+
+      superclass.respond_to?(:complexity) ? superclass.complexity : nil
+    end
+  end
+
+  # Run in graphql-ruby's analysis only when the class has a `result` of its own.
+  def analyze?
+    self.class.instance_method(:result).owner != Lighthouse::GraphQL::ComplexityAnalyzer && super
+  end
+
+  def result
+    nil
+  end
+end

data/lib/lighthouse/config.rb

@@ -12,14 +12,15 @@ module Lighthouse
     # Where each kind of class a schema refers to by name is looked up. Query and
     # mutation fields resolve to GraphQL::Schema::Resolver / Mutation classes,
     # builders compose onto a relation, validators check arguments: distinct
-    # contracts, so distinct namespaces (app/graphql/queries, .../mutations, ...).
+    # contracts, so distinct namespaces (app/graphql/resolvers, .../mutations, ...).
     DEFAULT_NAMESPACES = {
-      queries: ['Queries'],
+      queries: ['Resolvers'],
       mutations: ['Mutations'],
       builders: ['Builders'],
       validators: ['Validators'],
       events: ['Events'],
-      subscriptions: ['Subscriptions']
+      subscriptions: ['Subscriptions'],
+      analyzers: ['Analyzers']
     }.freeze
 
     # Every setting reset! forgets, so the next read falls back to its default.

data/lib/lighthouse/directive_resolvers/convention_resolver.rb

@@ -4,14 +4,17 @@ require_relative 'base'
 
 # Resolves a Query or Mutation field that has no resolving directive by
 # convention, as PHP Lighthouse does: `Query.latestPosts` resolves to
-# `Queries::LatestPosts` (a GraphQL::Schema::Resolver), `Mutation.publishPost`
-# to `Mutations::PublishPost` (a GraphQL::Schema::Mutation), looked up in
+# `Resolvers::LatestPosts` (a GraphQL::Schema::Resolver, by graphql-ruby's
+# convention a Resolvers::BaseResolver), `Mutation.publishPost` to
+# `Mutations::PublishPost` (a GraphQL::Schema::Mutation), looked up in
 # Config.namespaces[:queries] / [:mutations] at call time so code reloading
 # keeps working. Not a directive: SchemaGenerator installs it.
 class Lighthouse::GraphQL::DirectiveResolvers::ConventionResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
-  def initialize(field_def, type_def, kind)
+  # `base`: the class the schema's base_types require the class to inherit from.
+  def initialize(field_def, type_def, kind, base = nil)
     super(field_def, type_def, nil)
     @kind = kind
+    @base = base
   end
 
   def define_resolver(target_type_class)
@@ -31,6 +34,12 @@ class Lighthouse::GraphQL::DirectiveResolvers::ConventionResolver < Lighthouse::
     ROOT_KINDS[type.respond_to?(:graphql_name) ? type.graphql_name : type.to_s]
   end
 
+  # The class a root field resolves to, without its namespace: `LatestPosts`
+  # for `latestPosts`.
+  def self.class_name_for(field_def)
+    field_def.name.to_s.camelize
+  end
+
   private
 
   def resolve_by_convention(inner, obj, args, ctx)
@@ -43,6 +52,7 @@ class Lighthouse::GraphQL::DirectiveResolvers::ConventionResolver < Lighthouse::
             "#{klass} resolves #{location}, so it must inherit from GraphQL::Schema::Resolver " \
             '(or GraphQL::Schema::Mutation).'
     end
+    Lighthouse::GraphQL::ResolverBases.check!(klass, @base, location)
 
     Lighthouse::GraphQL::ResolverDispatch.call(klass, @field_def, obj, args, ctx)
   end
@@ -61,7 +71,7 @@ class Lighthouse::GraphQL::DirectiveResolvers::ConventionResolver < Lighthouse::
   end
 
   def class_name
-    @class_name ||= @field_def.name.to_s.camelize
+    @class_name ||= self.class.class_name_for(@field_def)
   end
 
   def location

data/lib/lighthouse/directive_resolvers/convert_empty_strings_resolver.rb

@@ -19,7 +19,7 @@ require_relative 'base'
 # carried the directive.
 #
 # The conversion is a wrapper around the field's resolver (outermost, order
-# 6), so every kind of resolver — directives, @field, Queries::/Mutations::
+# 6), so every kind of resolver — directives, @field, Resolvers::/Mutations::
 # classes, the default reader — and @validator see the converted arguments,
 # and other fields sharing an input type are unaffected. SchemaGenerator
 # installs it too, without the directive on the field, when an argument or

data/lib/lighthouse/directive_resolvers/subscription_resolver.rb

@@ -8,8 +8,9 @@ require_relative 'base'
 # Config.namespaces[:subscriptions] at call time so code reloading keeps
 # working. The class is a GraphQL::Schema::Subscription, which may include
 # Lighthouse::GraphQL::Subscription for PHP Lighthouse's hooks. A field
-# with no class still works: it is a Lighthouse::GraphQL::Subscription::Default
-# whose update is the broadcast root, which is all `@broadcast` needs.
+# with no class still works: it resolves with the schema's base_types[:subscription]
+# when given, else with Lighthouse::GraphQL::Subscription::Default, whose update
+# is the broadcast root, which is all `@broadcast` needs.
 #
 # graphql-ruby registers a subscription through the class its field was
 # built from, which a field built from SDL has not. The field is therefore
@@ -38,20 +39,27 @@ class Lighthouse::GraphQL::DirectiveResolvers::SubscriptionDirectiveResolver < L
   attr_reader :field_def
 
   # The class this field stands for: the one @subscription names, else the
-  # conventional one, else the default.
+  # conventional one, else the schema's base subscription, else the default.
   def subscription_class
     klass = find_class
-    return Lighthouse::GraphQL::Subscription::Default unless klass
+    return base || Lighthouse::GraphQL::Subscription::Default unless klass
 
     unless klass.is_a?(Class) && klass < ::GraphQL::Schema::Subscription
       raise Lighthouse::DefinitionError, "#{klass} resolves #{location}, so it must inherit from GraphQL::Schema::Subscription."
     end
 
+    Lighthouse::GraphQL::ResolverBases.check!(klass, base, location)
+
     klass
   end
 
   private
 
+  # The schema's base_types[:subscription], or nil.
+  def base
+    (@opts[:bases] || {})[:subscriptions]
+  end
+
   def find_class
     namespaces = Lighthouse::Config.namespaces[:subscriptions]
     named = directive_arg('class') if @directive_node

data/lib/lighthouse/directives/registry.rb

@@ -218,6 +218,7 @@ class Lighthouse::DirectiveRegistry
     register_definition('cacheControl', Lighthouse::GraphQL::CacheControl::DEFINITION)
     Lighthouse::GraphQL::CacheControl::TYPE_DEFINITIONS.each { |name, sdl| register_type_definition(name, sdl) }
     register_definition('feature', Lighthouse::GraphQL::FeatureDirective::DEFINITION)
+    register_definition('complexity', Lighthouse::GraphQL::Complexity::DEFINITION)
     Lighthouse::GraphQL::FeatureDirective::TYPE_DEFINITIONS.each { |name, sdl| register_type_definition(name, sdl) }
     Lighthouse::GraphQL::Directives::WhereConditionsDirective::DEFINITIONS.each do |name, definition|
       register_definition(name, definition)

data/lib/lighthouse/events/execution_trace.rb

@@ -33,7 +33,8 @@ module Lighthouse::Events::ExecutionTrace
       result = query.result_values
       return unless result.is_a?(Hash)
 
-      merge_extensions(result, Lighthouse::Events.dispatch(Lighthouse::Events::BuildExtensionsResponse.new(result, nil)))
+      complexity = Lighthouse::GraphQL::Complexity.query_complexity(query)
+      merge_extensions(result, Lighthouse::Events.dispatch(Lighthouse::Events::BuildExtensionsResponse.new(result, complexity)))
       manipulate = Lighthouse::Events::ManipulateResult.new(result)
       Lighthouse::Events.dispatch(manipulate)
       result.replace(manipulate.result) unless manipulate.result.equal?(result)

data/lib/lighthouse/events/lifecycle.rb

@@ -71,7 +71,9 @@ module Lighthouse::Events
 
   # A query ran. A listener may return an Events::ExtensionsResponse (or an
   # Array of them), which is merged into the result's "extensions".
-  # `query_complexity` is nil unless it was computed.
+  # `query_complexity` is the query's complexity score, as graphql-ruby checks it
+  # against max_complexity (see GraphQL::Complexity); nil for a query that
+  # failed validation, which is never scored.
   class BuildExtensionsResponse < Event
     attr_reader :result, :query_complexity
 

data/lib/lighthouse/field_resolver_stack.rb

@@ -3,17 +3,18 @@
 # Install a field's resolvers innermost first (see
 # DirectiveRegistry#resolution_order), so each wrapper decorates the ones
 # before it. Besides its directives, a field gets the conventional
-# Queries::/Mutations:: resolver when it is a root field with no resolving
+# Resolvers::/Mutations:: resolver when it is a root field with no resolving
 # directive, and argument validation when an input type it takes carries
 # @validator. The registry replaces a hardcoded `case dnode.name`: adding a
 # directive is "register a class", not "edit the generator".
 module Lighthouse::GraphQL::FieldResolverStack
   module_function
 
-  def apply(type, field_def, directives, root_kind)
-    opts = { root_kind: root_kind }
+  # `bases`: { root kind => base class } from the schema's base_types (ResolverBases).
+  def apply(type, field_def, directives, root_kind, bases: {})
+    opts = { root_kind: root_kind, bases: bases }
     steps = directive_steps(type, field_def, directives, opts)
-    steps << convention_step(type, field_def, root_kind) if root_kind && !resolving_directive?(directives)
+    steps << convention_step(type, field_def, root_kind, bases) if root_kind && !resolving_directive?(directives)
     steps << validator_step(type, field_def, opts) if input_validation?(field_def, directives)
     steps << empty_strings_step(type, field_def, opts) if empty_string_conversion?(field_def, directives)
 
@@ -38,13 +39,13 @@ module Lighthouse::GraphQL::FieldResolverStack
     directives.any? { |d| registry.resolution_class(d.name) && !registry.wrapper?(d.name) }
   end
 
-  def convention_step(type, field_def, root_kind)
+  def convention_step(type, field_def, root_kind, bases = {})
     resolvers = Lighthouse::GraphQL::DirectiveResolvers
     resolver =
       if root_kind == :subscriptions
-        resolvers::SubscriptionDirectiveResolver.new(field_def, type, nil, root_kind: root_kind)
+        resolvers::SubscriptionDirectiveResolver.new(field_def, type, nil, root_kind: root_kind, bases: bases)
       else
-        resolvers::ConventionResolver.new(field_def, type, root_kind)
+        resolvers::ConventionResolver.new(field_def, type, root_kind, bases[root_kind])
       end
     [0, -> { resolver.define_resolver(type) }]
   end

data/lib/lighthouse/graphql/version.rb

@@ -2,6 +2,6 @@
 
 module Lighthouse
   module GraphQL
-    VERSION = '0.3.0'
+    VERSION = '0.4.0'
   end
 end

data/lib/lighthouse/rb_lighthouse.rb

@@ -44,6 +44,7 @@ require_relative 'namespaces'
   events/lifecycle
   events/execution_trace
   events/schema_build
+  resolver_bases
   schema_generator
   schema_cache
   persisted_queries
@@ -55,6 +56,8 @@ require_relative 'namespaces'
   caching
   cache_control
   feature_directive
+  complexity
+  complexity_analyzer
   broadcasting
   subscription
   pagination

data/lib/lighthouse/resolver_bases.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# The base classes of the classes root fields resolve to, given to `get_schema`
+# beside graphql-ruby's own base types:
+#
+#   Lighthouse::GraphQL::RbLightHouse.get_schema(options: { base_types: {
+#     resolver: Resolvers::BaseResolver, mutation: Mutations::BaseMutation,
+#     subscription: Subscriptions::BaseSubscription, object: Types::BaseObject
+#   } })
+#
+# graphql-ruby's `from_definition` knows only the SDL's own kinds (object,
+# interface, union, scalar, enum, input_object), so these three are taken out
+# before it sees the rest. Each one given:
+#
+# - is the class every class of its kind must inherit from: a Query, Mutation or
+#   Subscription field's class, found by convention or through
+#   @subscription(class:), that does not raises Lighthouse::DefinitionError when
+#   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.
+module Lighthouse::GraphQL::ResolverBases
+  # base_types key => the graphql-ruby class the base must inherit from.
+  GRAPHQL_CLASSES = {
+    resolver: ::GraphQL::Schema::Resolver,
+    mutation: ::GraphQL::Schema::Mutation,
+    subscription: ::GraphQL::Schema::Subscription
+  }.freeze
+
+  # Root kind => base_types key.
+  KEYS = { queries: :resolver, mutations: :mutation, subscriptions: :subscription }.freeze
+
+  module_function
+
+  # Take the three keys out of opts[:base_types] (the caller's Hash is not
+  # changed) and return { root kind => base class } for those given.
+  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)
+    given.each { |key, klass| validate!(key, klass) }
+    KEYS.filter_map { |kind, key| [kind, given[key]] if given[key] }.to_h
+  end
+
+  def validate!(key, klass)
+    expected = GRAPHQL_CLASSES.fetch(key)
+    return if klass.is_a?(Class) && klass < expected
+
+    raise Lighthouse::DefinitionError, "base_types[:#{key}] must be a subclass of #{expected}, not #{klass.inspect}."
+  end
+
+  # Raise unless `klass`, which resolves the field at `location`, inherits from
+  # `base` (nil: no base was given).
+  def check!(klass, base, location)
+    return if base.nil? || klass <= base
+
+    raise Lighthouse::DefinitionError,
+          "#{klass} resolves #{location}, so it must inherit from #{base}, the schema's base class for it (base_types)."
+  end
+end