lighthouse-graphql 0.3.0 → 0.5.0

data/lib/generators/lighthouse/install/install_generator.rb

@@ -1,23 +1,38 @@
 # frozen_string_literal: true
 
 require 'rails/generators'
+require 'generators/graphql/install_generator'
 require 'lighthouse-graphql'
-
-# `rails generate lighthouse:install` — sets a Rails app up for Lighthouse:
-# the initializer, a starter SDL file, the schema class, a controller and
-# its route, plus the graphql-config file IDEs read. Rerunning it skips the
-# route, SDL and .gitignore entries that are already in place.
+require_relative '../base_classes'
+
+# `rails generate lighthouse:install` — sets a Rails app up for Lighthouse, on
+# top of graphql-ruby's own install, which it runs first (`graphql:install
+# --no-relay --skip-graphiql --skip-query-logs`, keeping the files the app has):
+# graphql-ruby writes the base classes every graphql-ruby app has (Types::Base*,
+# Resolvers::BaseResolver, Mutations::BaseMutation), its controller and route.
+# Lighthouse then puts its own over what graphql-ruby wrote in this run:
+#
+# - the schema class, built from the SDL (graphql-ruby's is code-first);
+# - the controller, with Lighthouse::GraphQL::Controller;
+# - no Types::QueryType / MutationType: the SDL declares the root types;
+# - Mutations::BaseMutation a GraphQL::Schema::Mutation, as the SDL declares a
+#   mutation's arguments (graphql-ruby's is a RelayClassicMutation, one `input:`);
 #
-# It coexists with graphql-ruby's `graphql:install`, which writes the same
-# controller path and route: an existing schema class or controller is kept
-# (pass --force to replace it) instead of overwritten, so an app already
-# serving a graphql-ruby schema keeps doing so until it is pointed at ours.
+# and adds the initializer, a starter SDL file, Subscriptions::BaseSubscription
+# and the graphql-config file IDEs read. Rerunning it skips what is in place. A
+# schema class or controller the app had before is kept (pass --force to replace
+# it), so an app already serving a graphql-ruby schema keeps doing so until it
+# is pointed at ours.
 class Lighthouse::Generators::InstallGenerator < Rails::Generators::Base
+  include Lighthouse::Generators::BaseClasses
+
   CONTROLLER = 'app/controllers/graphql_controller.rb'
+  ROOT_TYPES = %w[app/graphql/types/query_type.rb app/graphql/types/mutation_type.rb].freeze
+  BASE_MUTATION = 'app/graphql/mutations/base_mutation.rb'
 
   source_root File.expand_path('templates', __dir__)
 
-  desc 'Install Lighthouse: initializer, starter schema, schema class, controller, route and IDE config.'
+  desc 'Install Lighthouse: initializer, starter schema, schema class, base classes, controller, route and IDE config.'
 
   class_option :schema, type: :string, default: 'AppSchema',
                         desc: 'Name of the schema constant to generate'
@@ -28,6 +43,13 @@ class Lighthouse::Generators::InstallGenerator < Rails::Generators::Base
   class_option :skip_ide, type: :boolean, default: false,
                           desc: 'Skip graphql.config.yml and the .gitignore entries for the IDE helper files'
 
+  # graphql-ruby's install, for the base classes. What it writes that Lighthouse
+  # replaces is noted, so a file the app had before is never touched.
+  def install_graphql_ruby
+    @before = ([schema_path, CONTROLLER, BASE_MUTATION] + ROOT_TYPES).select { |path| exist?(path) }
+    invoke 'graphql:install', [], schema: schema_name, relay: false, skip_graphiql: true, skip_query_logs: true, skip: true
+  end
+
   def create_initializer
     template 'initializer.rb.tt', 'config/initializers/lighthouse.rb'
   end
@@ -42,17 +64,39 @@ class Lighthouse::Generators::InstallGenerator < Rails::Generators::Base
   end
 
   def create_schema_class
-    path = File.join('app/graphql', "#{schema_name.underscore}.rb")
-    return if keep_existing?(path)
+    return if keep_existing?(schema_path)
+
+    template 'schema.rb.tt', schema_path, force: true
+  end
+
+  # The SDL declares the root types: graphql-ruby's code-first ones go. Not when
+  # the app keeps a code-first schema of its own, which graphql-ruby's install
+  # pointed at them.
+  def remove_root_types
+    return unless exist?(schema_path) && File.read(File.join(destination_root, schema_path)).include?('RbLightHouse.get_schema')
+
+    ROOT_TYPES.each { |path| remove_file path unless before?(path) }
+  end
+
+  # The SDL declares a mutation's arguments, so its class is a plain
+  # GraphQL::Schema::Mutation, not graphql-ruby's RelayClassicMutation.
+  def adapt_base_mutation
+    return if before?(BASE_MUTATION) || !exist?(BASE_MUTATION)
+
+    gsub_file BASE_MUTATION, 'GraphQL::Schema::RelayClassicMutation', 'GraphQL::Schema::Mutation'
+    gsub_file BASE_MUTATION, /^\s*input_object_class .*\n/, ''
+  end
 
-    template 'schema.rb.tt', path
+  # Subscriptions::BaseSubscription, which graphql-ruby has none of (see BaseClasses).
+  def create_base_subscription
+    write_base_class(:subscriptions, Lighthouse::Config.namespaces[:subscriptions].first)
   end
 
   def create_controller
-    return if options[:skip_controller]
+    return remove_graphql_ruby_controller if options[:skip_controller]
     return if (@kept_controller = keep_existing?(CONTROLLER))
 
-    template 'graphql_controller.rb.tt', CONTROLLER
+    template 'graphql_controller.rb.tt', CONTROLLER, force: true
   end
 
   def add_route
@@ -93,26 +137,58 @@ class Lighthouse::Generators::InstallGenerator < Rails::Generators::Base
 
       Lighthouse is installed. Next steps:
         1. Describe your API in #{sdl_folder}/*.graphql (the starter schema assumes a User model).
-        2. Generate the IDE helper files:  bin/rails lighthouse:ide_helper
-        3. #{serve}
+        2. Resolve a field in Ruby when a directive is not enough:  bin/rails g lighthouse:query LatestPosts
+           (it inherits from Resolvers::BaseResolver, which graphql-ruby's install wrote; lighthouse:mutation and
+           lighthouse:subscription write the others)
+        3. Give a type Ruby methods, a union or interface its resolve_type, a scalar its coercion:
+           bin/rails g graphql:object Post (or graphql:union, graphql:interface, graphql:scalar),
+           then include Lighthouse::GraphQL::Type in the class
+        4. Generate the IDE helper files:  bin/rails lighthouse:ide_helper
+        5. #{serve}
     MSG
   end
 
   private
 
-  # Files another generator may own (graphql-ruby's install writes the same
-  # controller) are left alone unless --force is given.
+  # A file the app had before this run is left alone unless --force is given;
+  # one graphql-ruby's install wrote in this run is Lighthouse's to replace.
   def keep_existing?(path)
-    return false if options[:force] || !File.exist?(File.join(destination_root, path))
+    return false if options[:force] || !before?(path)
 
     say_status :skip, "#{path} already exists (pass --force to replace it)", :yellow
     true
   end
 
+  def before?(path)
+    @before.include?(path)
+  end
+
+  def exist?(path)
+    File.exist?(File.join(destination_root, path))
+  end
+
+  def schema_path
+    File.join('app/graphql', "#{schema_name.underscore}.rb")
+  end
+
+  # --skip-controller: the app serves the schema itself, so graphql-ruby's
+  # controller and route, if its install just wrote them, go.
+  def remove_graphql_ruby_controller
+    return if before?(CONTROLLER)
+
+    remove_file CONTROLLER
+    gsub_file 'config/routes.rb', %r{^\s*post "/graphql", to: "graphql#execute"\n}, '' if exist?('config/routes.rb')
+  end
+
   def schema_name
     options[:schema].camelize
   end
 
+  # `Resolvers::BaseResolver`, for the schema class template.
+  def base_class_constant(kind)
+    "#{Lighthouse::Config.namespaces[kind].first}::#{base_class_name(kind)}"
+  end
+
   def sdl_folder
     options[:sdl_folder].delete_suffix('/')
   end

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

@@ -12,25 +12,34 @@ Lighthouse.configure do |config|
 
   # Where classes named by the schema are looked up, by kind. A Query or Mutation
   # field without a resolving directive resolves by convention: Query.latestPosts
-  # to Queries::LatestPosts (a GraphQL::Schema::Resolver), Mutation.publishPost
-  # to Mutations::PublishPost (a GraphQL::Schema::Mutation). @builder classes
+  # to Resolvers::LatestPosts (a Resolvers::BaseResolver), Mutation.publishPost
+  # to Mutations::PublishPost (a Mutations::BaseMutation). @builder classes
   # come from :builders and @validator contracts from :validators. A Subscription
-  # field resolves to Subscriptions::PostUpdated (a GraphQL::Schema::Subscription),
-  # and @event(dispatch:) classes come from :events. Generate them with
-  # `rails g lighthouse:query|mutation|subscription|builder|validator Name`.
+  # field resolves to Subscriptions::PostUpdated (a Subscriptions::BaseSubscription),
+  # @event(dispatch:) classes come from :events, and the graphql-ruby analyzers
+  # @complexity(resolver:) names from :analyzers. Post.readingTime, with no
+  # resolving directive, resolves with Types::PostType#reading_time (a
+  # Types::BaseObject including Lighthouse::GraphQL::Type), from :types. Generate them with
+  # `rails g lighthouse:query|mutation|subscription|type|builder|validator Name`.
   # config.namespaces = {
-  #   queries: ['Queries'], mutations: ['Mutations'], subscriptions: ['Subscriptions'],
-  #   builders: ['Builders'], validators: ['Validators'], events: ['Events']
+  #   queries: ['Resolvers'], mutations: ['Mutations'], subscriptions: ['Subscriptions'],
+  #   builders: ['Builders'], validators: ['Validators'], events: ['Events'], analyzers: ['Analyzers'],
+  #   types: ['Types']
   # }
 
   # Namespaces tried, in order, for models (@all(model: "User")) and for
-  # @field(resolver:) on types other than Query and Mutation. Fully-qualified
-  # names (containing `::`) are used as-is.
+  # @field(resolver:) on types other than Query and Mutation, after :queries
+  # (@field(resolver: "Posts::TagsCount") is Resolvers::Posts::TagsCount).
+  # Fully-qualified names (containing `::`) are used as-is.
   # config.resolver_namespaces = ['App::Graphql']
 
-  # Store for @cache and @clearCache.
+  # Store for @cache, @clearCache and @throttle's counts.
   # config.cache_store = Rails.cache
 
+  # Where @upload stores a file: call(file, disk:, path:, public:) returns what the
+  # argument holds. By default an ActiveStorage blob, and its signed id.
+  # config.upload_store = Lighthouse::GraphQL::UploadStore
+
   # Run @create/@update/@createMany/@updateMany in a database transaction.
   # config.transactional_mutations = true
 

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

@@ -2,9 +2,28 @@
 
 # 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. graphql-ruby builds the
+# SDL's types from the others (written by `rails g graphql:install`), and type
+# classes (Types::PostType, Types::DateTimeType, ...) inherit from them.
 <%= 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,
+      interface: Types::BaseInterface,
+      union: Types::BaseUnion,
+      scalar: Types::BaseScalar,
+      enum: Types::BaseEnum,
+      input_object: Types::BaseInputObject
+    }
   }
 )
+
+# 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/async_mutation_job.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'active_job'
+
+# Runs what resolves an @async mutation field, from a queue. Loaded on first
+# use — the activejob gem is optional — so it is autoloaded, as BroadcastJob.
+# The schema is passed by name; the field's resolver runs with the arguments
+# and context values the request serialized, inside the schema's Dataloader.
+class Lighthouse::GraphQL::AsyncMutationJob < ActiveJob::Base # rubocop:disable Rails/ApplicationJob
+  def perform(schema_name, type_name, field_name, arguments, context_values)
+    schema = schema_name.constantize
+    type = schema.get_type(type_name)
+    inner = Lighthouse::GraphQL::DirectiveResolvers::AsyncDirectiveResolver.inner(type, field_name)
+    context = ::GraphQL::Query.new(schema, '{ __typename }', context: context_values.merge(lighthouse_async: true)).context
+    context.dataloader.run_isolated { inner.call(nil, arguments.transform_keys(&:to_sym), context) }
+  end
+end

data/lib/lighthouse/complexity.rb

@@ -0,0 +1,175 @@
+# 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)
+    reference = %w[resolver class].filter_map { |name| Lighthouse::Support::DirectiveArgs.literal(directive, name) }.first
+    return unless reference
+
+    class_name, = Lighthouse::GraphQL::DirectiveResolvers::FieldDirectiveResolver.reference(reference)
+
+    -> { Lighthouse::GraphQL::DirectiveResolvers::FieldDirectiveResolver.lookup(class_name, kind) }
+  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