lighthouse-graphql 0.2.1 → 0.4.0

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

@@ -1,57 +1,19 @@
 # frozen_string_literal: true
 
+# Serves the schema: StartRequest/EndRequest events, persisted queries, batching,
+# variables, Cache-Control. See docs/getting-started.md.
 class GraphqlController < ApplicationController
   # If this endpoint is called from outside this domain, null the session
   # instead of failing CSRF verification:
   # protect_from_forgery with: :null_session
 
-  def execute
-    # PersistedQueries.execute resolves Apollo-style persisted queries when
-    # config.persisted_queries is on, and otherwise runs params[:query] as is.
-    result = Lighthouse::GraphQL::PersistedQueries.execute(
-      <%= schema_name %>,
-      query: params[:query],
-      extensions: params[:extensions],
-      variables: prepare_variables(params[:variables]),
-      operation_name: params[:operationName],
-      context: {
-        # Read by @guard and the @can* directives — see config/initializers/lighthouse.rb.
-        # current_user: current_user
-      }
-    )
-    # The Cache-Control header the selected fields' @cacheControl hints allow
-    # (a no-op when the schema has none).
-    Lighthouse::GraphQL::CacheControl.apply(response, result)
-    render json: result
-  rescue StandardError => e
-    raise e unless Rails.env.development?
+  include Lighthouse::GraphQL::Controller
 
-    handle_error_in_development(e)
-  end
+  lighthouse_schema <%= schema_name %>
 
   private
 
-  # Variables arrive as a JSON string (GET or form posts) or as parameters.
-  def prepare_variables(variables_param)
-    case variables_param
-    when String
-      variables_param.present? ? JSON.parse(variables_param) || {} : {}
-    when Hash
-      variables_param
-    when ActionController::Parameters
-      variables_param.to_unsafe_hash
-    when nil
-      {}
-    else
-      raise ArgumentError, "Unexpected parameter: #{variables_param}"
-    end
-  end
-
-  def handle_error_in_development(error)
-    logger.error(error.message)
-    logger.error(error.backtrace.join("\n"))
-
-    render json: { errors: [{ message: error.message, backtrace: error.backtrace }], data: {} },
-           status: :internal_server_error
-  end
+  # Read by @guard and the @can* directives — see config/initializers/lighthouse.rb.
+  # Defaults to { current_user: current_user } when the controller has a current_user.
+  # def graphql_context = { current_user: current_user }
 end

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

@@ -12,12 +12,16 @@ 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
-  # come from :builders and @validator contracts from :validators. Generate them
-  # with `rails g lighthouse:query|mutation|builder|validator Name`.
+  # 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 Subscriptions::BaseSubscription),
+  # @event(dispatch:) classes come from :events, and the graphql-ruby analyzers
+  # @complexity(resolver:) names from :analyzers. Generate them with
+  # `rails g lighthouse:query|mutation|subscription|builder|validator Name`.
   # config.namespaces = {
-  #   queries: ['Queries'], mutations: ['Mutations'], builders: ['Builders'], validators: ['Validators']
+  #   queries: ['Resolvers'], mutations: ['Mutations'], subscriptions: ['Subscriptions'],
+  #   builders: ['Builders'], validators: ['Validators'], events: ['Events'], analyzers: ['Analyzers']
   # }
 
   # Namespaces tried, in order, for models (@all(model: "User")) and for
@@ -31,6 +35,19 @@ Lighthouse.configure do |config|
   # Run @create/@update/@createMany/@updateMany in a database transaction.
   # config.transactional_mutations = true
 
+  # Treat "" as null on every field's inputs, as if each carried
+  # @convertEmptyStringsToNull. Read when the schema is built.
+  # config.convert_empty_strings_to_null = false
+
+  # What "trashed" means for @softDeletes, @trashed, @restore and @forceDelete.
+  # By default each model is inspected: paranoia, then discard, then a deleted_at column.
+  # config.soft_deletes = Lighthouse::Support::SoftDeletes::Column.new(:archived_at)
+
+  # Run @broadcast's subscription triggers in an ActiveJob (a directive's
+  # shouldQueue: overrides it), and the queue they go to (nil: the default one).
+  # config.queue_broadcasts = false
+  # config.broadcast_queue = nil
+
   # --- For large schemas and high traffic (all off by default) ---------------
   # Cache the built schema document in tmp/cache, keyed by the SDL and
   # everything that shapes it; warm it at deploy with `bin/rails lighthouse:cache`.
@@ -56,6 +73,11 @@ Lighthouse.configure do |config|
   # config.authenticated_user = ->(ctx) { ctx[:current_user] }
   # config.policy_user = ->(ctx) { ctx[:pundit_user] || ctx[:current_user] }
   # config.authorizer = ->(user, record, ability, args = []) { Pundit.policy!(user, record).public_send("#{ability}?", *args) }
+
+  # Feature flags read by @feature (Flipper by default): the actor a flag is
+  # checked for, and the check itself.
+  # config.feature_actor = ->(ctx) { ctx[:current_user] }
+  # config.feature_checker = ->(name, actor, _ctx) { Flipper.enabled?(name.to_sym, actor) }
 end
 
 # Register app-defined directives and federation reference resolvers inside
@@ -65,3 +87,10 @@ end
 #   Lighthouse::DirectiveRegistry.register(Directives::Upcase)
 #   Lighthouse::ReferenceResolver.register('User') { |ref, _ctx| User.find_by(id: ref['id']) }
 # end
+
+# Listen to Lighthouse's request, schema-build and execution events. A listener
+# may return a value where the event says so, as BuildExtensionsResponse does.
+# See docs/events.md.
+# Lighthouse::Events.listen(Lighthouse::Events::EndExecution) do |event|
+#   Rails.logger.info("[GraphQL] #{event.result.to_h['errors']&.size.to_i} errors")
+# end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative 'class_generator'
+
+# `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 the class of a Subscription field (a Subscriptions::BaseSubscription) in app/graphql/subscriptions.'
+
+  private
+
+  def kind = :subscriptions
+
+  def 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
+    <<~RUBY
+      # 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} < #{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)
+          true
+        end
+
+        # The subscription request. Its return value answers the client right away;
+        # the default returns nothing (:no_response).
+        #
+        # def subscribe(**args)
+        #   :no_response
+        # end
+
+        # Each update; `object` is what the mutation broadcast (@broadcast passes its
+        # result). The default returns `object`. Return NO_UPDATE to skip this
+        # subscriber, or another value to send that instead.
+        #
+        # def update(**args)
+        #   return NO_UPDATE unless context[:current_user]
+        #
+        #   object
+        # end
+
+        # What @broadcast triggers this subscription with, for the `root` a mutation
+        # returned. graphql-ruby updates only the subscribers whose arguments equal
+        # these, so return one value for every argument the field takes (`{}` for
+        # a field with none).
+        def self.trigger_arguments(root, context)
+          {}
+        end
+      end
+    RUBY
+  end
+
+  def lighthouse_body
+    <<~RUBY
+      # 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
+        end
+
+        # Should this subscriber receive the broadcast of `root`?
+        def filter?(root, **args)
+          true
+        end
+
+        # What the update resolves the field with.
+        def resolve_payload(root, **args)
+          root
+        end
+      end
+    RUBY
+  end
+
+  def field_name = class_basename.camelize(:lower)
+
+  def usage
+    "Subscription.#{field_name} resolves to #{full_class_name} — add the field to your SDL, " \
+      "and trigger it from a mutation with @broadcast(subscription: \"#{field_name}\") or `schema.subscriptions.trigger`."
+  end
+end

data/lib/lighthouse/broadcast_job.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'active_job'
+
+# Triggers a subscription from a queue (@broadcast with shouldQueue, or
+# Config.queue_broadcasts). Loaded on first use — the activejob gem is
+# optional — so it is autoloaded rather than listed in rb_lighthouse.rb.
+# The schema is passed by name, and the root (an Active Record model, say)
+# through ActiveJob's serialization. (A gem has no ApplicationJob to inherit from.)
+class Lighthouse::GraphQL::BroadcastJob < ActiveJob::Base # rubocop:disable Rails/ApplicationJob
+  def perform(schema_name, subscription, trigger_arguments, root, scope = nil)
+    Lighthouse::GraphQL::Broadcasting.trigger(schema_name.constantize, subscription, trigger_arguments, root, scope)
+  end
+end

data/lib/lighthouse/broadcasting.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+# What @broadcast does once a mutation has resolved: trigger the subscription
+# field on the schema's subscriptions backend (`schema.subscriptions.trigger`),
+# inline or, when queued, in a Lighthouse::GraphQL::BroadcastJob. Also checks,
+# when the schema is built, that every @broadcast names a Subscription field.
+module Lighthouse::GraphQL::Broadcasting
+  module_function
+
+  # Broadcast `root` to the subscribers of the field `name`.
+  def broadcast(schema, name, root, context, should_queue: nil)
+    return unless backend?(schema, name)
+
+    klass = subscription_class(schema, name)
+    return unless triggerable?(schema, name, klass)
+
+    arguments = klass.respond_to?(:trigger_arguments) ? klass.trigger_arguments(root, context) : {}
+    scope = klass.respond_to?(:trigger_scope) ? klass.trigger_scope(root, context) : nil
+
+    if should_queue.nil? ? Lighthouse::Config.queue_broadcasts : should_queue
+      enqueue(schema, name, arguments, root, scope)
+    else
+      trigger(schema, name, arguments, root, scope)
+    end
+  end
+
+  # Can a trigger of `klass` reach anybody? graphql-ruby delivers to the
+  # subscribers whose arguments equal the trigger's. A class with exact-argument
+  # topics (a plain GraphQL::Schema::Subscription, or topic_by :arguments) that
+  # leaves `trigger_arguments` at the default `{}`, on a field with a required
+  # argument, therefore never reaches a single subscriber: each of them passed
+  # that argument. That is certain, so it is reported through Config.on_error
+  # (raised in a test environment, logged otherwise) and nothing is triggered.
+  # Arguments that are all optional are not reported: argument-less subscribers
+  # do match `{}`, which can be exactly what the class wants.
+  def triggerable?(schema, name, klass)
+    field = subscription_field(schema, name)
+    required = field ? required_arguments(field) : []
+    return true if required.empty? || trigger_arguments_defined?(klass)
+
+    Lighthouse::Config.handle_error(
+      Lighthouse::DefinitionError.new(
+        "@broadcast(subscription: #{name.inspect}) can reach nobody: #{klass} matches subscribers by exact arguments, " \
+        "but #{field.owner.graphql_name}.#{field.name} requires #{required.map { |arg| arg.graphql_name.inspect }.join(', ')} " \
+        'and the class defines no `self.trigger_arguments(root, context)` saying what to trigger with. ' \
+        "Define it, e.g. `def self.trigger_arguments(root, _context) = { #{required.first.graphql_name.underscore}: root.id.to_s }`, " \
+        'or include Lighthouse::GraphQL::Subscription for one topic per field, filtered by `filter?`.'
+      )
+    )
+    false
+  end
+
+  # Does a trigger of `klass` need its own trigger_arguments to match anyone?
+  # Not for the field-wide topic of a class including Lighthouse::GraphQL::Subscription.
+  def trigger_arguments_defined?(klass)
+    return true if klass < Lighthouse::GraphQL::Subscription && klass.topic_by == :field
+
+    klass.respond_to?(:trigger_arguments) && klass.method(:trigger_arguments).owner != Lighthouse::GraphQL::Subscription::ClassMethods
+  end
+
+  def required_arguments(field)
+    field.arguments.values.select { |arg| arg.type.non_null? && !arg.default_value? }
+  end
+
+  # Trigger the subscription now. Misuse (arguments the field does not take, a
+  # missing scope) goes through Config.on_error.
+  def trigger(schema, name, arguments, root, scope = nil)
+    schema.subscriptions.trigger(name, arguments, root, scope: scope)
+  rescue ::GraphQL::Subscriptions::InvalidTriggerError, ::GraphQL::Subscriptions::SubscriptionScopeMissingError => e
+    Lighthouse::Config.handle_error(e)
+  end
+
+  def enqueue(schema, name, arguments, root, scope)
+    if schema.name.nil?
+      raise Lighthouse::DefinitionError,
+            'A queued @broadcast reaches its schema by name, but this schema is anonymous: assign it to a constant ' \
+            '(AppSchema = Lighthouse::GraphQL::RbLightHouse.get_schema).'
+    end
+
+    job = broadcast_job
+    queue = Lighthouse::Config.broadcast_queue
+    (queue ? job.set(queue: queue) : job).perform_later(schema.name, name, arguments, root, scope)
+  end
+
+  def broadcast_job
+    Lighthouse::GraphQL::BroadcastJob
+  rescue LoadError
+    raise Lighthouse::DefinitionError, 'Queueing @broadcast needs ActiveJob: add the activejob gem, or set shouldQueue: false.'
+  end
+
+  # Is there a backend to trigger? Reported through Config.on_error when not.
+  def backend?(schema, name)
+    return true if schema.subscriptions
+
+    Lighthouse::Config.handle_error(
+      Lighthouse::DefinitionError.new(
+        "@broadcast(subscription: #{name.inspect}) has nowhere to broadcast: #{schema.name || 'the schema'} has no subscriptions backend. " \
+        'Install one, e.g. `use GraphQL::Subscriptions::ActionCableSubscriptions`, or pass ' \
+        '`options: { using: { GraphQL::Subscriptions::ActionCableSubscriptions => {} } }` to get_schema.'
+      )
+    )
+    false
+  end
+
+  # The Subscription field called `name` (as written in the SDL or in
+  # snake_case), or nil.
+  def subscription_field(schema, name)
+    fields = schema.subscription&.fields || {}
+    fields[name.to_s] || fields[name.to_s.camelize(:lower)]
+  end
+
+  # The class the field stands for (see SubscriptionDirectiveResolver).
+  def subscription_class(schema, name)
+    subscription_field(schema, name)&.resolver || Lighthouse::GraphQL::Subscription::Default
+  end
+
+  # Every @broadcast in the schema must name a field of its Subscription type.
+  def validate!(schema)
+    schema.types.each_value do |type|
+      next unless type.kind.object?
+
+      type.fields.each_value do |field_def|
+        broadcasts(field_def).each do |directive|
+          name = Lighthouse::Support::DirectiveArgs.literal(directive, 'subscription')
+          next if subscription_field(schema, name)
+
+          raise Lighthouse::DefinitionError, unknown_subscription(schema, type, field_def, name)
+        end
+      end
+    end
+  end
+
+  def broadcasts(field_def)
+    (field_def.ast_node&.directives || []).select { |directive| directive.name == 'broadcast' }
+  end
+
+  def unknown_subscription(schema, type, field_def, name)
+    where = "@broadcast on #{type.graphql_name}.#{field_def.name}"
+    return "#{where}: the schema has no Subscription type, so there is no subscription #{name.inspect}." unless schema.subscription
+
+    "#{where}: #{schema.subscription.graphql_name} has no field #{name.inspect}."
+  end
+end

data/lib/lighthouse/cache_control.rb

@@ -18,8 +18,11 @@
 # read the result with CacheControl.header(result) and set it on the
 # response (see `apply`).
 module Lighthouse::GraphQL::CacheControl
-  DEFINITION = 'directive @cacheControl(maxAge: Int! = 0, scope: CacheControlScope! = PUBLIC, ' \
-               'inheritMaxAge: Boolean! = false) on FIELD_DEFINITION | OBJECT | INTERFACE | UNION'
+  # Arguments with a default are nullable, not `Type! = default` as in PHP: graphql-ruby
+  # 2.5 does not fill in a directive argument's default, so a non-null one would be
+  # refused wherever it is left out. Left out or null, it takes its default.
+  DEFINITION = 'directive @cacheControl(maxAge: Int = 0, scope: CacheControlScope = PUBLIC, ' \
+               'inheritMaxAge: Boolean = false) on FIELD_DEFINITION | OBJECT | INTERFACE | UNION'
 
   TYPE_DEFINITIONS = {
     'CacheControlScope' => <<~GRAPHQL.chomp

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