lighthouse-graphql 0.4.0 → 0.5.0

data/lib/generators/lighthouse/base_classes.rb

@@ -3,72 +3,55 @@
 require 'rails/generators'
 require 'lighthouse-graphql'
 
-# The base class graphql-ruby's convention puts in each namespace:
-# Resolvers::BaseResolver, Mutations::BaseMutation and
-# Subscriptions::BaseSubscription. The classes Lighthouse generates inherit from
-# them, so what every class of a kind shares (a concern, graphql-ruby's base type
-# hookups) is written once, in the base. graphql-ruby's `graphql:install` writes
-# the first two the same way.
+# The base class graphql-ruby's convention puts in each namespace, which the
+# classes Lighthouse generates inherit from: Resolvers::BaseResolver,
+# Mutations::BaseMutation and Subscriptions::BaseSubscription.
+#
+# graphql-ruby's `graphql:install` writes the first two (and every Types::Base*),
+# and `lighthouse:install` runs it: Lighthouse does not write copies of them. It
+# writes only the base graphql-ruby has none of, BaseSubscription, which
+# includes Lighthouse's subscription concern. A generator that finds a base
+# missing says how to get it.
 #
 # A base that already exists is never replaced, not even with --force: it holds
-# the app's own code, and one written by graphql-ruby works as it is.
+# the app's own code.
 module Lighthouse::Generators::BaseClasses
-  BASES = {
-    queries: {
-      name: 'BaseResolver',
-      source: <<~RUBY
-        # What every class resolving a Query field shares: Lighthouse resolves
-        # Query.latestPosts to Resolvers::LatestPosts by convention, and every such
-        # class inherits from this one. graphql-ruby's `graphql:install` writes the
-        # same class.
-        class BaseResolver < GraphQL::Schema::Resolver
-        end
-      RUBY
-    },
-    mutations: {
-      name: 'BaseMutation',
-      source: <<~RUBY
-        # What every class resolving a Mutation field shares: Lighthouse resolves
-        # Mutation.publishPost to Mutations::PublishPost by convention, and every such
-        # class inherits from this one. The SDL declares the arguments, so it is a
-        # plain GraphQL::Schema::Mutation; the GraphQL::Schema::RelayClassicMutation
-        # graphql-ruby's `graphql:install` writes (one `input:` argument) works too.
-        class BaseMutation < GraphQL::Schema::Mutation
-        end
-      RUBY
-    },
-    subscriptions: {
-      name: 'BaseSubscription',
-      source: <<~RUBY
-        # What every class resolving a Subscription field shares. The concern is PHP
-        # Lighthouse's model: every subscriber of a field gets every broadcast, and the
-        # class's `filter?` decides who receives it. A subclass that defines
-        # graphql-ruby's own `authorized?` or `update` keeps them, and `topic_by
-        # :arguments` brings back graphql-ruby's exact-argument matching.
-        class BaseSubscription < GraphQL::Schema::Subscription
-          include Lighthouse::GraphQL::Subscription
-        end
-      RUBY
-    }
+  NAMES = { queries: 'BaseResolver', mutations: 'BaseMutation', subscriptions: 'BaseSubscription' }.freeze
+
+  # The bases Lighthouse writes itself, graphql-ruby having none.
+  SOURCES = {
+    subscriptions: <<~RUBY
+      # What every class resolving a Subscription field shares. The concern is PHP
+      # Lighthouse's model: every subscriber of a field gets every broadcast, and the
+      # class's `filter?` decides who receives it. A subclass that defines
+      # graphql-ruby's own `authorized?` or `update` keeps them, and `topic_by
+      # :arguments` brings back graphql-ruby's exact-argument matching.
+      class BaseSubscription < GraphQL::Schema::Subscription
+        include Lighthouse::GraphQL::Subscription
+      end
+    RUBY
   }.freeze
 
   private
 
   # The base class name for `kind` (`BaseResolver`), or nil for a kind without one.
   def base_class_name(kind)
-    BASES.dig(kind, :name)
+    NAMES[kind]
   end
 
-  # Write the base class of `kind` into `namespace`, unless its file exists.
+  # Write the base class of `kind` into `namespace` when Lighthouse owns it and
+  # it is missing; say how to get one graphql-ruby owns.
   def write_base_class(kind, namespace)
-    base = BASES[kind]
-    return unless base
+    return unless base_class_name(kind)
 
     path = base_class_path(kind, namespace)
     if File.exist?(File.join(destination_root, path))
       say_status :skip, "#{path} already exists", :yellow
+    elsif SOURCES[kind]
+      create_file path, ruby_source(namespace.split('::'), SOURCES[kind])
     else
-      create_file path, ruby_source(namespace.split('::'), base[:source])
+      say_status :missing, "#{path}: graphql-ruby writes it — run `bin/rails g lighthouse:install` (which runs graphql:install), " \
+                           "or write #{namespace}::#{base_class_name(kind)} yourself", :red
     end
   end
 

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

@@ -1,23 +1,34 @@
 # frozen_string_literal: true
 
 require 'rails/generators'
+require 'generators/graphql/install_generator'
 require 'lighthouse-graphql'
 require_relative '../base_classes'
 
-# `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` — 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:
 #
-# 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, 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:`);
+#
+# 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__)
 
@@ -32,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
@@ -46,23 +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
 
-    template 'schema.rb.tt', path
+  # 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
 
-  # 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 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
+
+  # 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
@@ -104,23 +138,48 @@ 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. 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}
+           (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

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

@@ -17,21 +17,29 @@ 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 them with
+  # `rails g lighthouse:query|mutation|subscription|type|builder|validator 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.
+  # 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

@@ -4,15 +4,22 @@
 # 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.
+# 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: {
       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
+      subscription: <%= base_class_constant(:subscriptions) %>,
+      object: Types::BaseObject,
+      interface: Types::BaseInterface,
+      union: Types::BaseUnion,
+      scalar: Types::BaseScalar,
+      enum: Types::BaseEnum,
+      input_object: Types::BaseInputObject
     }
   }
 )

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

@@ -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

@@ -20,7 +20,8 @@ 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.
@@ -32,13 +33,14 @@ module Lighthouse
       convert_empty_strings_to_null
       soft_deletes
       queue_broadcasts broadcast_queue
+      global_id upload_store
     ].freeze
 
     class << self
       attr_writer :sdl_folder, :resolver_namespaces, :on_error, :authenticated_user, :policy_user, :authorizer, :cache_store,
                   :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, :upload_store
 
       def sdl_folder
         @sdl_folder ||= (defined?(Rails) && Rails.respond_to?(:root) ? Rails.root.join('graphql').to_s : nil)
@@ -104,6 +106,15 @@ 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
+
+      # Stores the file an @upload argument carries: `call(file, disk:, path:,
+      # public:)` returns what the argument holds instead. An ActiveStorage blob's
+      # signed id by default.
+      def upload_store = @upload_store || Lighthouse::GraphQL::UploadStore
+
       def persisted_queries_store
         @persisted_queries_store || cache_store
       end

data/lib/lighthouse/controller.rb

@@ -19,7 +19,8 @@ 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.
 #
@@ -46,11 +47,11 @@ 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
@@ -80,6 +81,11 @@ module Lighthouse::GraphQL::Controller
     respond_to?(:current_user, true) ? { current_user: current_user } : {}
   end
 
+  # graphql_context, with the client's IP (for @throttle) unless it sets its own.
+  def lighthouse_context
+    { remote_ip: request.remote_ip }.merge(graphql_context)
+  end
+
   def graphql_schema
     source = lighthouse_schema_source
     case source
@@ -103,11 +109,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,7 +134,7 @@ 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

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

data/lib/lighthouse/directive_resolvers/argument_binding.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# What @bind(class:) puts in place of an argument's value: the record of a model
+# whose `column` matches it (a list's records, for a list), eager-loading `with`;
+# or what a class's `call(value, context)` returns. A value that matches nothing
+# is a validation error on the argument, as PHP Lighthouse's, unless `optional`.
+class Lighthouse::GraphQL::DirectiveResolvers::ArgumentBinding
+  def initialize(directive, argument, field_def)
+    @directive = directive
+    @argument = argument
+    @field_def = field_def
+  end
+
+  def bind(value, ctx)
+    klass = Lighthouse::Support::ModelResolver.constantize(arg('class'))
+    raise Lighthouse::DefinitionError, "@bind(class: #{arg('class').inspect}) on #{@argument.name} names no class." unless klass
+    return call(klass, value, ctx) unless model?(klass)
+
+    value.is_a?(Array) ? records(klass, value) : record(klass, value)
+  end
+
+  private
+
+  def arg(name)
+    Lighthouse::Support::DirectiveArgs.literal(@directive, name)
+  end
+
+  def model?(klass)
+    defined?(::ActiveRecord::Base) && klass.is_a?(Class) && klass < ::ActiveRecord::Base
+  end
+
+  def call(klass, value, ctx)
+    bound = (klass.respond_to?(:call) ? klass : klass.new).call(value, ctx)
+    bound.nil? ? missing : bound
+  end
+
+  def scope(klass)
+    with = Array(arg('with'))
+    with.empty? ? klass.all : klass.preload(*Lighthouse::Support::Preload.associations(with))
+  end
+
+  def record(klass, value)
+    scope(klass).find_by(column => value) || missing
+  end
+
+  def records(klass, values)
+    found = scope(klass).where(column => values).index_by { |record| record.public_send(column).to_s }
+    bound = values.map { |value| found[value.to_s] }
+    bound.include?(nil) ? missing(bound) : bound
+  end
+
+  def column
+    arg('column') || 'id'
+  end
+
+  def missing(partial = nil)
+    return partial if arg('optional')
+
+    raise Lighthouse::ValidationError.new(@field_def.name, @argument.name => ["The selected #{@argument.name} is invalid."])
+  end
+end