lighthouse-graphql 0.4.0 → 0.6.0

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

@@ -1,37 +1,71 @@
 # frozen_string_literal: true
 
 require 'rails/generators'
+require 'generators/graphql/install_generator'
 require 'lighthouse-graphql'
 require_relative '../base_classes'
+require_relative 'graphql_ruby_install'
 
-# `rails generate lighthouse:install` — sets a Rails app up for Lighthouse:
-# the initializer, a starter SDL file, the schema class, the base classes of
-# resolvers, mutations and subscriptions, a controller and its route, plus the
-# graphql-config file IDEs read. Rerunning it skips the route, SDL, base classes
-# and .gitignore entries that are already in place.
+# `rails generate lighthouse:install` — puts Lighthouse on top of graphql-ruby's
+# own install (`rails g graphql:install`, with whichever of its options the app
+# chose: --relay, --batch, --skip-mutation-root-type, --schema, --directory,
+# ...). When the app has none, it runs graphql:install first, with its
+# defaults. It then adapts what graphql-ruby wrote, instead of writing its own:
 #
-# 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.
+# - the schema class (`class AppSchema < GraphQL::Schema`) becomes Lighthouse's,
+#   built from the SDL on everything graphql-ruby wrote: its base types, base
+#   resolver and base mutation, and its code-first Types::QueryType /
+#   MutationType, which the SDL's root types extend, so their `field`s (Relay's
+#   `node` / `nodes`, what `graphql:mutation` adds) stay. Its Relay
+#   Types::NodeType is the SDL's Node. Everything else in the class is
+#   graphql-ruby's and stays, but the `resolve_type` stub (Lighthouse resolves
+#   types) and the root types it is built on;
+# - the example `test_field` goes from the root types;
+# - graphql-ruby's base object, interface, union and scalar include
+#   Lighthouse::GraphQL::Type, so every type class (Types::QueryType,
+#   Types::NodeType, what `graphql:object` writes) is Lighthouse's;
+# - with --batch, the schema uses GraphQL::Dataloader too, which Lighthouse's
+#   directives batch through;
+# - graphql-ruby's controller, as its install wrote it, becomes one with
+#   Lighthouse::GraphQL::Controller.
+#
+# It adds the initializer, a starter SDL file and the graphql-config file IDEs
+# read, and with --subscriptions, Subscriptions::BaseSubscription. Rerunning it
+# skips what is in place.
 class Lighthouse::Generators::InstallGenerator < Rails::Generators::Base
   include Lighthouse::Generators::BaseClasses
+  include Lighthouse::Generators::GraphqlRubyInstall
 
   CONTROLLER = 'app/controllers/graphql_controller.rb'
 
   source_root File.expand_path('templates', __dir__)
 
-  desc 'Install Lighthouse: initializer, starter schema, schema class, base classes, controller, route and IDE config.'
+  desc "Install Lighthouse on graphql-ruby's install: schema class, base classes, controller, initializer, starter SDL and IDE config."
 
-  class_option :schema, type: :string, default: 'AppSchema',
-                        desc: 'Name of the schema constant to generate'
+  class_option :schema, type: :string,
+                        desc: "The schema class to adopt; for graphql:install, when it runs, its name (default: graphql-ruby's)"
   class_option :sdl_folder, type: :string, default: 'graphql',
                             desc: 'Folder, relative to the app root, holding the *.graphql files'
+  class_option :subscriptions, type: :boolean, default: false,
+                               desc: 'Add Subscriptions::BaseSubscription, the base of the classes Subscription fields resolve to'
   class_option :skip_controller, type: :boolean, default: false,
-                                 desc: 'Skip the GraphqlController and its route'
+                                 desc: "Leave graphql-ruby's GraphqlController as it is"
   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: the app's, or one now, with graphql-ruby's defaults.
+  def install_graphql_ruby
+    return if schema_path
+
+    say_status :invoke, 'graphql:install (no graphql-ruby schema found)', :blue
+    invoke 'graphql:install', [], graphql_install_options
+    @schema_path = nil
+    return if schema_path
+
+    raise Thor::Error, "No graphql-ruby schema class (class #{options[:schema] || 'AppSchema'} < GraphQL::Schema) under app/: " \
+                       'run `bin/rails g graphql:install` first.'
+  end
+
   def create_initializer
     template 'initializer.rb.tt', 'config/initializers/lighthouse.rb'
   end
@@ -45,24 +79,62 @@ class Lighthouse::Generators::InstallGenerator < Rails::Generators::Base
     template 'schema.graphql.tt', File.join(sdl_folder, 'schema.graphql')
   end
 
-  def create_schema_class
-    path = File.join('app/graphql', "#{schema_name.underscore}.rb")
-    return if keep_existing?(path)
+  # Subscriptions::BaseSubscription, which graphql-ruby has none of (see BaseClasses).
+  def create_base_subscription
+    write_base_class(:subscriptions, Lighthouse::Config.namespaces[:subscriptions].first) if options[:subscriptions]
+  end
 
-    template 'schema.rb.tt', path
+  # graphql-ruby's schema class, built by Lighthouse from the SDL on its classes.
+  def adopt_schema_class
+    source = read(schema_path)
+    if lighthouse?(source)
+      say_status :skip, "#{schema_path} is Lighthouse's already", :yellow
+      return
+    end
+
+    declaration = /^([ \t]*)class (\S+) < GraphQL::Schema[ \t]*\n/
+    indent, name = source.match(declaration).captures
+    gsub_file schema_path, declaration, "#{indent}#{schema_comment(indent)}#{indent}class #{name} < #{schema_superclass(indent)}\n"
+    gsub_file schema_path, /^[ \t]*(query|mutation|subscription)\(Types::(Query|Mutation|Subscription)Type\)\n/, ''
+    gsub_file schema_path, /^(#{indent}\)\n)\n+/, '\\1'
+    gsub_file schema_path, RESOLVE_TYPE_STUB, "\n"
+    add_dataloader if source.include?('use GraphQL::Batch') && source.exclude?('use GraphQL::Dataloader')
   end
 
-  # Resolvers::BaseResolver, Mutations::BaseMutation and Subscriptions::BaseSubscription,
-  # in the namespaces Config.namespaces names first (see BaseClasses).
-  def create_base_classes
-    BASES.each_key { |kind| write_base_class(kind, Lighthouse::Config.namespaces[kind].first) }
+  # The example field goes; the root types' own fields stay.
+  def adapt_root_types
+    %w[query_type mutation_type subscription_type].each do |name|
+      path = types_path("#{name}.rb")
+      gsub_file path, TEST_FIELD, "\n" if exist?(path) && read(path).match?(TEST_FIELD)
+    end
   end
 
-  def create_controller
-    return if options[:skip_controller]
-    return if (@kept_controller = keep_existing?(CONTROLLER))
+  # Every type class is Lighthouse's: graphql-ruby's base object, interface,
+  # union and scalar include Lighthouse::GraphQL::Type, so the classes that
+  # inherit from them (Types::QueryType, Types::NodeType, what `graphql:object`
+  # writes) lend their methods to the SDL's types of their name.
+  def adapt_type_bases
+    TYPE_CONCERN_ANCHORS.each do |name, anchor|
+      path = types_path("#{name}.rb")
+      next if !exist?(path) || read(path).include?('Lighthouse::GraphQL::Type')
+
+      indent = read(path)[anchor, 1]
+      next unless indent
+
+      indent += '  ' unless name == 'base_interface'
+      inject_into_file path, "#{indent}# Lighthouse's: the class of the SDL type of its name lends that type its methods.\n" \
+                             "#{indent}include Lighthouse::GraphQL::Type\n", after: anchor
+    end
+  end
+
+  # graphql-ruby's controller, as its install wrote it, serves the schema with
+  # Lighthouse's concern. One the app has changed is left alone.
+  def adapt_controller
+    return if options[:skip_controller] || !exist?(CONTROLLER)
+    return if read(CONTROLLER).include?('Lighthouse::GraphQL::Controller')
+    return @kept_controller = true unless graphql_ruby_controller?(read(CONTROLLER))
 
-    template 'graphql_controller.rb.tt', CONTROLLER
+    template 'graphql_controller.rb.tt', CONTROLLER, force: true
   end
 
   def add_route
@@ -72,8 +144,7 @@ class Lighthouse::Generators::InstallGenerator < Rails::Generators::Base
     return unless File.exist?(routes)
     return if File.read(routes).include?('graphql#execute')
 
-    # Byte-identical to graphql-ruby's install route, so whichever generator
-    # runs second finds it in place and does not add it again.
+    # Byte-identical to graphql-ruby's install route.
     route 'post "/graphql", to: "graphql#execute"'
   end
 
@@ -94,40 +165,49 @@ class Lighthouse::Generators::InstallGenerator < Rails::Generators::Base
   def show_next_steps
     serve =
       if @kept_controller
-        "Serve it: #{CONTROLLER} was kept — have it call #{schema_name}.execute(...) to serve Lighthouse's schema."
+        "Serve it: #{CONTROLLER} was changed from graphql-ruby's, so it was kept — " \
+          "include Lighthouse::GraphQL::Controller in it, or keep calling #{schema_name}.execute(...)."
       else
         'Query it:  POST /graphql  {"query": "{ users { data { id name } paginatorInfo { total } } }"}'
       end
 
     say <<~MSG
 
-      Lighthouse is installed. Next steps:
+      Lighthouse is installed on graphql-ruby's install (#{schema_path}). Next steps:
         1. Describe your API in #{sdl_folder}/*.graphql (the starter schema assumes a User model).
-        2. Resolve a field in Ruby when a directive is not enough:  bin/rails g lighthouse:query LatestPosts
-           (its class inherits from Resolvers::BaseResolver; mutations and subscriptions have a base too)
-        3. Generate the IDE helper files:  bin/rails lighthouse:ide_helper
-        4. #{serve}
+        2. Resolve a field in Ruby when a directive is not enough, as in graphql-ruby: a method of
+           Types::QueryType (Query.latestPosts -> #latest_posts), a `field` of its own there,
+           `bin/rails g graphql:mutation`, or a Resolvers::BaseResolver subclass named after the field.
+        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);
+           the class is Lighthouse's through its base (Lighthouse::GraphQL::Type)
+        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.
-  def keep_existing?(path)
-    return false if options[:force] || !File.exist?(File.join(destination_root, path))
-
-    say_status :skip, "#{path} already exists (pass --force to replace it)", :yellow
-    true
+  def schema_superclass(indent)
+    lines = base_types.map { |key, name| "#{indent}      #{key}: #{name}" }
+    "Lighthouse::GraphQL::RbLightHouse.get_schema(\n#{indent}  options: {\n#{indent}    base_types: {\n" \
+      "#{lines.join(",\n")}\n#{indent}    }\n#{indent}  }\n#{indent})"
   end
 
-  def schema_name
-    options[:schema].camelize
+  def schema_comment(indent)
+    <<~RUBY.gsub(/^/, indent).delete_prefix(indent)
+      # Lighthouse builds the schema from the SDL in #{sdl_folder}/, on the classes graphql-ruby's
+      # install wrote (base_types): the SDL's root types extend the code-first ones, whose
+      # `field`s stay the schema's, and every type, resolver and mutation class inherits from
+      # its kind's base. The rest of the class is graphql-ruby's.
+    RUBY
   end
 
-  # `Resolvers::BaseResolver`, for the schema class template.
-  def base_class_constant(kind)
-    "#{Lighthouse::Config.namespaces[kind].first}::#{base_class_name(kind)}"
+  def add_dataloader
+    anchor = /^([ \t]*)use GraphQL::Batch\n/
+    indent = read(schema_path)[anchor, 1]
+    inject_into_file schema_path, "#{indent}# Lighthouse's directives batch through GraphQL::Dataloader, beside GraphQL::Batch.\n" \
+                                  "#{indent}use GraphQL::Dataloader\n", after: anchor
   end
 
   def sdl_folder

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

@@ -17,21 +17,23 @@ Lighthouse.configure do |config|
   # 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`.
+  # @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 a
+  # subscription, builder or validator with `rails g lighthouse:subscription|builder|validator Name`,
+  # and a type class with graphql-ruby's `rails g graphql:object|union|interface|scalar Name`.
   # config.namespaces = {
   #   queries: ['Resolvers'], mutations: ['Mutations'], subscriptions: ['Subscriptions'],
-  #   builders: ['Builders'], validators: ['Validators'], events: ['Events'], analyzers: ['Analyzers']
+  #   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.
-  # config.cache_store = Rails.cache
-
   # Run @create/@update/@createMany/@updateMany in a database transaction.
   # config.transactional_mutations = 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/caching.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
+require 'active_support/cache'
 require 'digest'
 require 'json'
 require 'securerandom'
 
-# Keys and invalidation for @cache / @clearCache over Config.cache_store
-# (Rails.cache by default).
+# The app's cache stores, and keys and invalidation for @cache / @clearCache.
+#
+# Lighthouse keeps no store of its own, as PHP Lighthouse uses Laravel's: @cache,
+# @clearCache and APQ use Rails.cache (config.cache_store), and @throttle counts
+# where Rails' own `rate_limit` does, in the controller's cache_store.
 #
 # PHP Lighthouse invalidates with cache tags, which Rails cache stores do not
 # have (and `delete_matched` is not universal). Instead every entry key embeds
@@ -19,8 +23,10 @@ module Lighthouse::GraphQL::Caching
 
   module_function
 
+  # Rails.cache; outside Rails, one in-memory store for the process.
   def store
-    Lighthouse::Config.cache_store
+    rails_cache = ::Rails.cache if defined?(::Rails) && ::Rails.respond_to?(:cache)
+    rails_cache || (@memory_store ||= ActiveSupport::Cache::MemoryStore.new)
   end
 
   def entry_key(type, id, field, args, user_key)

data/lib/lighthouse/complexity.rb

@@ -151,11 +151,12 @@ module Lighthouse::GraphQL::Complexity
 
   # 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
+    reference = %w[resolver class].filter_map { |name| Lighthouse::Support::DirectiveArgs.literal(directive, name) }.first
+    return unless reference
 
-    namespaces = kind ? Lighthouse::Config.namespaces[kind] : Lighthouse::Config.resolver_namespaces
-    -> { Lighthouse::Support::ModelResolver.constantize(class_name, namespaces: namespaces) }
+    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

data/lib/lighthouse/config.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'active_support/cache'
-
 module Lighthouse
   # Convenience entrypoint: `Lighthouse.configure { |c| c.resolver_namespaces = [...] }`.
   def self.configure(&block)
@@ -20,25 +18,27 @@ module Lighthouse
       validators: ['Validators'],
       events: ['Events'],
       subscriptions: ['Subscriptions'],
-      analyzers: ['Analyzers']
+      analyzers: ['Analyzers'],
+      types: ['Types']
     }.freeze
 
     # Every setting reset! forgets, so the next read falls back to its default.
     SETTINGS = %i[
-      sdl_folder resolver_namespaces namespaces cache_store transactional_mutations pagination_default_count pagination_max_count
+      sdl_folder resolver_namespaces namespaces transactional_mutations pagination_default_count pagination_max_count
       schema_cache schema_cache_path watch_sdl persisted_queries persisted_queries_store persisted_queries_ttl
       persisted_queries_manifest persisted_queries_only on_error directive_map authenticated_user policy_user authorizer
       feature_checker feature_actor
       convert_empty_strings_to_null
       soft_deletes
       queue_broadcasts broadcast_queue
+      global_id
     ].freeze
 
     class << self
-      attr_writer :sdl_folder, :resolver_namespaces, :on_error, :authenticated_user, :policy_user, :authorizer, :cache_store,
+      attr_writer :sdl_folder, :resolver_namespaces, :on_error, :authenticated_user, :policy_user, :authorizer,
                   :transactional_mutations, :schema_cache, :watch_sdl, :persisted_queries, :persisted_queries_store, :persisted_queries_only,
                   :queue_broadcasts,
-                  :convert_empty_strings_to_null, :feature_checker, :feature_actor
+                  :convert_empty_strings_to_null, :feature_checker, :feature_actor, :global_id
 
       def sdl_folder
         @sdl_folder ||= (defined?(Rails) && Rails.respond_to?(:root) ? Rails.root.join('graphql').to_s : nil)
@@ -64,16 +64,6 @@ module Lighthouse
         @namespaces = namespaces.merge(overrides.to_h.transform_keys(&:to_sym).transform_values { |v| Array(v) })
       end
 
-      # Store backing @cache and @clearCache. Defaults to Rails.cache.
-      def cache_store
-        @cache_store ||=
-          if defined?(Rails) && Rails.respond_to?(:cache) && Rails.cache
-            Rails.cache
-          else
-            ActiveSupport::Cache::MemoryStore.new
-          end
-      end
-
       # --- Subscriptions (used by @broadcast) ----------------------------------
       #
       # queue_broadcasts  perform @broadcast triggers in a Lighthouse::GraphQL::BroadcastJob
@@ -89,7 +79,7 @@ module Lighthouse
       # schema_cache_path     where; default Rails.root/tmp/cache/lighthouse
       # watch_sdl             reload the app (and so the schema) when a .graphql file changes
       # persisted_queries     accept Apollo's Automatic Persisted Queries (PersistedQueries)
-      # persisted_queries_store     where APQ keeps queries; default cache_store
+      # persisted_queries_store     where APQ keeps queries; default Rails.cache
       # persisted_queries_ttl       how long they live there (seconds; nil: until evicted)
       # persisted_queries_manifest  a manifest of trusted operations, served by hash
       # persisted_queries_only      reject any operation not in the manifest
@@ -104,8 +94,12 @@ module Lighthouse
       # when the schema is built, so set it in an initializer.
       def convert_empty_strings_to_null = @convert_empty_strings_to_null || false
 
+      # Encodes and decodes Relay global ids (@globalId, @node): `encode(type, id)`
+      # and `decode(global_id)` -> [type, id]. Base64 of "Type:id" by default.
+      def global_id = @global_id || Lighthouse::GraphQL::GlobalId
+
       def persisted_queries_store
-        @persisted_queries_store || cache_store
+        @persisted_queries_store || Lighthouse::GraphQL::Caching.store
       end
 
       # Pagination defaults, overridden by a directive's defaultCount / maxCount.

data/lib/lighthouse/controller.rb

@@ -19,10 +19,16 @@ require 'json'
 #
 # `execute` dispatches StartRequest, reads the variables (a JSON String, a Hash
 # or parameters), runs the operation through PersistedQueries.execute (or
-# PersistedQueries.multiplex for a batch, a JSON array body), sets the
+# PersistedQueries.multiplex for a batch, a JSON array body; a multipart
+# request's operations, with its files, as MultipartRequest reads them), sets the
 # Cache-Control header the selected fields' @cacheControl hints allow, renders
 # the JSON and dispatches EndRequest. In development an error renders as JSON.
 #
+# A field's @throttle that renders past its limit (its `with:` method, or
+# `head :too_many_requests`, rate_limit's default on Rails 7.2) ends the request
+# with that response, as a before_action that renders does: the operation stops
+# there (Performed), and `execute` renders nothing more.
+#
 # Hooks, private so they are not actions: `graphql_context` (default:
 # `{ current_user: current_user }` when the controller has a current_user, else
 # `{}`), `graphql_schema` and `graphql_variables(param)`. A controller with an
@@ -31,6 +37,11 @@ require 'json'
 module Lighthouse::GraphQL::Controller
   extend ActiveSupport::Concern
 
+  # Raised once a @throttle `with:` method has performed the response: control
+  # flow, as `throw :abort` in a before_action, so no `rescue StandardError` (a
+  # schema's rescue_from) catches it on its way out of the operation.
+  class Performed < Exception; end # rubocop:disable Lint/InheritException
+
   included do
     class_attribute :lighthouse_schema_source, instance_writer: false
   end
@@ -46,17 +57,17 @@ module Lighthouse::GraphQL::Controller
 
   def execute
     lighthouse_request do
-      batch = params[:_json]
-      if batch.is_a?(Array)
-        render json: lighthouse_batch(batch)
+      operations = lighthouse_operations
+      if operations.is_a?(Array)
+        render json: lighthouse_batch(operations.map { |operation| lighthouse_hash(operation) })
       else
-        result = lighthouse_operation
+        result = lighthouse_operation(operations)
         Lighthouse::GraphQL::CacheControl.apply(response, result)
         render json: result
       end
     end
   rescue StandardError => e
-    raise e unless defined?(::Rails) && ::Rails.env.development?
+    raise e unless defined?(::Rails) && ::Rails.env.development? && !rails_response?(e)
 
     lighthouse_development_error(e)
   end
@@ -64,13 +75,18 @@ module Lighthouse::GraphQL::Controller
   private
 
   # Dispatch StartRequest, run the block, dispatch EndRequest with the
-  # response. Only the outermost call dispatches.
+  # response. Only the outermost call dispatches, and stops the block where a
+  # @throttle `with:` method performed the response.
   def lighthouse_request
     return yield if @lighthouse_request_started
 
     @lighthouse_request_started = true
     Lighthouse::Events.dispatch(Lighthouse::Events::StartRequest.new(request))
-    result = yield
+    result = begin
+      yield
+    rescue Performed
+      nil
+    end
     Lighthouse::Events.dispatch(Lighthouse::Events::EndRequest.new(response))
     result
   end
@@ -80,6 +96,13 @@ module Lighthouse::GraphQL::Controller
     respond_to?(:current_user, true) ? { current_user: current_user } : {}
   end
 
+  # graphql_context, with what @throttle reads unless it sets its own: the
+  # client's IP (rate_limit's default by:) and the controller, whose cache_store,
+  # controller_path and methods rate_limit uses.
+  def lighthouse_context
+    { remote_ip: request.remote_ip, lighthouse_controller: self }.merge(graphql_context)
+  end
+
   def graphql_schema
     source = lighthouse_schema_source
     case source
@@ -103,11 +126,23 @@ module Lighthouse::GraphQL::Controller
     end
   end
 
-  def lighthouse_operation
+  # A multipart request's operation(s), a batch (a JSON array body), or the parameters.
+  def lighthouse_operations
+    Lighthouse::GraphQL::MultipartRequest.operations(params) || params[:_json] || params
+  end
+
+  # Parameters, or a Hash from a multipart request's JSON, read by key either way.
+  def lighthouse_hash(operation)
+    (operation.respond_to?(:to_unsafe_h) ? operation.to_unsafe_h : operation.to_h).with_indifferent_access
+  end
+
+  # `operation`: the request's parameters, or a multipart request's operation.
+  def lighthouse_operation(operation = params)
+    operation = operation.with_indifferent_access if operation.is_a?(Hash)
     Lighthouse::GraphQL::PersistedQueries.execute(
       graphql_schema,
-      query: params[:query], extensions: params[:extensions],
-      variables: graphql_variables(params[:variables]), operation_name: params[:operationName], context: graphql_context
+      query: operation[:query], extensions: operation[:extensions],
+      variables: graphql_variables(operation[:variables]), operation_name: operation[:operationName], context: lighthouse_context
     )
   end
 
@@ -116,11 +151,17 @@ module Lighthouse::GraphQL::Controller
   def lighthouse_batch(operations)
     operations = operations.map do |operation|
       { query: operation[:query], extensions: operation[:extensions], variables: graphql_variables(operation[:variables]),
-        operation_name: operation[:operationName], context: graphql_context }
+        operation_name: operation[:operationName], context: lighthouse_context }
     end
     Lighthouse::GraphQL::PersistedQueries.multiplex(graphql_schema, operations)
   end
 
+  # An error Rails answers with a status of its own (config.action_dispatch.rescue_responses):
+  # ActionController::TooManyRequests from @throttle is a 429 in development too.
+  def rails_response?(error)
+    ::ActionDispatch::ExceptionWrapper.status_code_for_exception(error.class.name) != 500
+  end
+
   def lighthouse_development_error(error)
     logger.error(error.message)
     logger.error(error.backtrace.join("\n"))

data/lib/lighthouse/dataloader_sources/preload_loader.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Eager-loads associations into every record the Dataloader collected, of
+# every parent, in one query per association: @with and @lazyLoad.
+class Lighthouse::GraphQL::DataloaderSources::PreloadLoader < GraphQL::Dataloader::Source
+  def initialize(associations, scopes)
+    super()
+    @associations = associations
+    @scopes = scopes
+  end
+
+  # keys: the records
+  def fetch(records)
+    Lighthouse::Support::Preload.records(records, @associations, @scopes)
+  end
+end

data/lib/lighthouse/dataloader_sources/relation_counts_loader.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# How many related records each parent has, for @withCount: every parent the
+# Dataloader collected in one GROUP BY query when the relation can be batched
+# (RelationBatch), else one COUNT per parent. Each count is kept on its parent
+# as `<relation>_count` (RelationCounts).
+class Lighthouse::GraphQL::DataloaderSources::RelationCountsLoader < GraphQL::Dataloader::Source
+  # Applies the directive's scopes to the related records, as RelationBatch
+  # applies a field's filters. A value, so equal scopes batch together.
+  Scopes = Struct.new(:names) do
+    def decorate_relation(relation, _args, _context)
+      Array(names).reduce(relation) { |scoped, scope| scoped.public_send(scope) }
+    end
+  end
+
+  def initialize(relation, scopes)
+    super()
+    @relation = relation.to_s
+    @scopes = Scopes.new(Array(scopes))
+  end
+
+  # keys: the parent records, of one class or several
+  def fetch(parents)
+    counts = {}.compare_by_identity
+    parents.group_by(&:class).each_value { |group| counts.merge!(counts_for(group)) }
+    parents.map do |parent|
+      Lighthouse::GraphQL::RelationCounts.write(parent, @relation, counts[parent])
+      counts[parent]
+    end
+  end
+
+  private
+
+  # { parent => count } for parents of one class.
+  def counts_for(parents)
+    batch = Lighthouse::GraphQL::RelationBatch.for(parents.first, @relation, {}, @scopes, nil)
+    return parents.index_with { |parent| own_count(parent) } unless batch
+
+    counts = batch.counts(parents)
+    parents.index_with { |parent| counts.fetch(batch.owner_key(parent), 0) }
+  end
+
+  def own_count(parent)
+    @scopes.decorate_relation(parent.public_send(@relation), nil, nil).count
+  end
+end

data/lib/lighthouse/default_resolve_dispatcher.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# The schema's default resolve while Lighthouse runs it. graphql-ruby asks that
+# one object for every field, for the type of a union's or interface's value
+# (`resolve_type`) and for scalar coercion: the dispatcher answers fields with
+# our generated resolvers, and hands everything else to the implementation it
+# replaced (SchemaImplementation).
+class Lighthouse::GraphQL::DefaultResolveDispatcher
+  def initialize(schema, previous)
+    @schema = schema
+    @previous = previous
+  end
+
+  def call(type, field, obj, arguments, ctx)
+    resolver = Lighthouse::GraphQL::GeneratedResolvers.generated_resolver(@schema, type, field)
+    return Lighthouse::GraphQL::GeneratedResolvers.invoke(resolver, obj, arguments, ctx) if resolver
+
+    @previous.call(type, field, obj, arguments, ctx)
+  end
+
+  def resolve_type(abstract_type, obj, ctx) = @previous.resolve_type(abstract_type, obj, ctx)
+
+  def coerce_input(type, value, ctx) = @previous.coerce_input(type, value, ctx)
+
+  def coerce_result(type, value, ctx) = @previous.coerce_result(type, value, ctx)
+end

data/lib/lighthouse/directive_resolvers/all_resolver.rb

@@ -27,7 +27,7 @@ class Lighthouse::GraphQL::DirectiveResolvers::AllDirectiveResolver < Lighthouse
 
     relation = Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply(relation, @field_def.ast_node, args, ctx, self)
 
-    relation = apply_where_filters(relation, args)
+    relation = apply_where_filters(relation, args, ctx)
     relation = relation.limit(args[:first]) if args[:first]
     relation = relation.offset(args[:offset]) if args[:offset]
     relation