lighthouse-graphql 0.3.0 → 0.5.0

data/lib/lighthouse/config.rb

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

data/lib/lighthouse/directive_resolvers/argument_transforms_resolver.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+# Rewrites the arguments a field receives, before it resolves, as PHP
+# Lighthouse's argument directives do. On an argument or an input field, in the
+# order the SDL lists them:
+#
+#   @globalId(decode:)  a Relay global id, decoded ([type, id], the type or the id)
+#   @trim               leading and trailing whitespace removed
+#   @hash               the value hashed with BCrypt, for a password column
+#   @drop               the value removed: the resolver never sees it
+#   @bind(class:)       the value replaced by the record(s) it identifies
+#   @upload             the uploaded file stored (Config.upload_store), its blob's signed id passed
+#
+#   type Mutation {
+#     signUp(email: String! @trim, password: String! @trim @hash, captcha: String @drop): User! @create
+#     assign(task: ID! @bind(class: "Task"), user: ID! @bind(class: "User")): Task! @field(resolver: "Assign")
+#   }
+#
+# @trim on a field trims every string it takes, nested inputs included. Lists
+# and input objects are walked; input objects that change are copied, never
+# mutated. Not a directive resolver: FieldResolverStack installs it twice, as
+# two phases. :rewrite (@globalId, @trim, @drop) is outermost, so @guard, the
+# @can* family and @validator see the rewritten values. :effects (@hash, @bind,
+# @upload) runs once those have let the call through, around whatever resolves
+# the field: a validator sees the password before it is hashed, and nothing is
+# stored or looked up for a call that is refused.
+class Lighthouse::GraphQL::DirectiveResolvers::ArgumentTransformsResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  PHASES = { rewrite: %w[globalId trim drop], effects: %w[hash bind upload] }.freeze
+  NAMES = PHASES.values.flatten.freeze
+  DROP = Object.new.freeze
+
+  DEFINITIONS = {
+    'trim' => <<~GRAPHQL.chomp,
+      """
+      Remove whitespace from the beginning and end of a given input.
+      On a field, of every string input it takes.
+      """
+      directive @trim on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION | FIELD_DEFINITION
+    GRAPHQL
+    'hash' => <<~GRAPHQL.chomp,
+      """
+      Hash an argument value with BCrypt (has_secure_password's), e.g. a password.
+      """
+      directive @hash on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION
+    GRAPHQL
+    'drop' => <<~GRAPHQL.chomp,
+      """
+      Ignore the user given value, don't pass it to the resolver.
+      """
+      directive @drop on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION
+    GRAPHQL
+    'bind' => <<~GRAPHQL.chomp,
+      """
+      Replace argument values with the corresponding model (or some other value)
+      before passing them to the resolver.
+      """
+      directive @bind(
+        "A model class, or a class whose `call(value, context)` returns what the value stands for."
+        class: String!
+        "The column the value is matched against, for a model."
+        column: String! = "id"
+        "Relations to eager-load on the bound records."
+        with: [String!]! = []
+        "Pass null instead of failing when no record matches."
+        optional: Boolean! = false
+      ) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION
+    GRAPHQL
+    'upload' => <<~GRAPHQL.chomp
+      """
+      Store the file an Upload argument carries, and pass along what Config.upload_store
+      answers instead: by default, the signed id of an ActiveStorage blob, which an
+      attachment attribute (has_one_attached) attaches.
+      """
+      directive @upload(
+        "The storage service to store the file on (an ActiveStorage service name). Defaults to the default one."
+        disk: String
+        "A prefix for the stored file's key."
+        path: String! = "/"
+        "Accepted for PHP Lighthouse parity: whether files are public is the service's setting."
+        public: Boolean! = false
+      ) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION
+    GRAPHQL
+  }.freeze
+
+  # Does the field take anything to rewrite in `phase`: @trim on the field
+  # itself, or an argument at any depth of input types carrying one of the
+  # phase's directives?
+  def self.transforms?(field_def, phase)
+    (phase == :rewrite && trims_all?(field_def)) || carried?(field_def.arguments, PHASES.fetch(phase))
+  end
+
+  def self.trims_all?(field_def)
+    (field_def.ast_node&.directives || []).any? { |d| d.name == 'trim' }
+  end
+
+  def self.carried?(argument_defs, names, seen = Set.new)
+    argument_defs.each_value.any? do |argument|
+      type = argument.type.unwrap
+      directives(argument, names).any? || (type.kind.input_object? && seen.add?(type.graphql_name) && carried?(type.arguments, names, seen))
+    end
+  end
+
+  def self.directives(argument, names = NAMES)
+    (argument.ast_node&.directives || []).select { |d| names.include?(d.name) }
+  end
+
+  def define_resolver(target_type_class)
+    me = self
+    argument_defs = @field_def.arguments
+    trim_all = phase == :rewrite && self.class.trims_all?(@field_def)
+    inner = capture_inner(target_type_class)
+
+    install(target_type_class, lambda do |obj, args, ctx|
+      inner.call(obj, args.is_a?(Hash) ? me.transform_hash(argument_defs, args, ctx, trim_all) : args, ctx)
+    end)
+  end
+
+  # The values with every argument's directives applied; a dropped one removed.
+  def transform_hash(argument_defs, values, ctx, trim_all)
+    by_keyword = Lighthouse::Support::Arguments.keyword_index(argument_defs)
+    values.each_with_object({}) do |(key, value), result|
+      transformed = transform_argument(by_keyword[key.to_sym], value, ctx, trim_all)
+      result[key] = transformed unless transformed.equal?(DROP)
+    end
+  end
+
+  private
+
+  def phase
+    @opts.fetch(:phase, :rewrite)
+  end
+
+  def transform_argument(argument, value, ctx, trim_all)
+    return value if argument.nil?
+
+    value = nested(argument.type, value, ctx, trim_all)
+    value = trim(value) if trim_all
+    self.class.directives(argument, PHASES.fetch(phase)).reduce(value) do |current, directive|
+      break DROP if current.equal?(DROP)
+
+      apply(directive, argument, current, ctx)
+    end
+  end
+
+  # Each directive's transform, a method taking (directive, argument, value, context).
+  TRANSFORMS = { 'globalId' => :decode_global_id, 'trim' => :trim_value, 'hash' => :hash_value, 'bind' => :bind, 'upload' => :upload }.freeze
+
+  def apply(directive, argument, value, ctx)
+    return DROP if directive.name == 'drop'
+    return value if value.nil?
+
+    send(TRANSFORMS.fetch(directive.name), directive, argument, value, ctx)
+  end
+
+  def decode_global_id(directive, _argument, value, _ctx)
+    decode(value, Lighthouse::Support::DirectiveArgs.literal(directive, 'decode') || 'ARRAY')
+  end
+
+  def trim_value(_directive, _argument, value, _ctx) = trim(value)
+
+  def hash_value(_directive, _argument, value, _ctx) = hash(value)
+
+  def upload(directive, argument, value, ctx)
+    return value.map { |item| upload(directive, argument, item, ctx) } if value.is_a?(Array)
+
+    options = %w[disk path public].to_h { |name| [name.to_sym, Lighthouse::Support::DirectiveArgs.literal(directive, name)] }
+    Lighthouse::Config.upload_store.call(value, **options.compact)
+  end
+
+  def decode(value, mode)
+    return value.map { |item| decode(item, mode) } if value.is_a?(Array)
+
+    type, id = Lighthouse::GraphQL::GlobalId.decode!(value)
+    { 'TYPE' => type, 'ID' => id }.fetch(mode.to_s, [type, id])
+  end
+
+  def trim(value)
+    case value
+    when String then value.strip
+    when Array then value.map { |item| trim(item) }
+    else value
+    end
+  end
+
+  def hash(value)
+    return value.map { |item| hash(item) } if value.is_a?(Array)
+
+    begin
+      require 'bcrypt'
+    rescue LoadError
+      raise Lighthouse::DefinitionError, '@hash needs the bcrypt gem (gem "bcrypt", as has_secure_password does).'
+    end
+    BCrypt::Password.create(value.to_s).to_s
+  end
+
+  def bind(directive, argument, value, ctx)
+    Lighthouse::GraphQL::DirectiveResolvers::ArgumentBinding.new(directive, argument, @field_def).bind(value, ctx)
+  end
+
+  # An input object's own arguments, transformed in a copy.
+  def nested(type, value, ctx, trim_all)
+    type = type.unwrap
+    return value unless type.kind.input_object? && !value.nil?
+    return value.map { |item| nested(type, item, ctx, trim_all) } if value.is_a?(Array)
+
+    transform_input(type, value, ctx, trim_all)
+  end
+
+  def transform_input(type, value, ctx, trim_all)
+    values = value.respond_to?(:to_kwargs) ? value.to_kwargs : value
+    return value unless values.is_a?(Hash)
+
+    transformed = transform_hash(type.arguments, values, ctx, trim_all)
+    return transformed unless value.respond_to?(:to_kwargs)
+
+    value.dup.tap { |copy| copy.instance_variable_set(:@ruby_style_hash, transformed) }
+  end
+end

data/lib/lighthouse/directive_resolvers/association_resolvers.rb

@@ -92,8 +92,8 @@ module Lighthouse::GraphQL::DirectiveResolvers
 
     # The field's scopes and filters on the association's query, for one
     # parent or a RelationBatch of them.
-    def decorate_relation(relation, args, _ctx)
-      apply_where_filters(scoped(relation), args)
+    def decorate_relation(relation, args, ctx)
+      apply_where_filters(scoped(relation), args, ctx)
     end
 
     protected

data/lib/lighthouse/directive_resolvers/async_resolver.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+# @async — run a mutation in a queued job and answer `true` at once, as PHP
+# Lighthouse's directive. What decides whether it may run does so in the
+# request: @guard, the @can* family, @validator and the argument directives, so
+# the client still gets their errors. What resolves it (@create, a Mutations::
+# class, ...) runs in Lighthouse::GraphQL::AsyncMutationJob, through ActiveJob,
+# with the arguments and the context values ActiveJob can serialize (records
+# included, through GlobalID; a request or a file is left out).
+#
+#   type Mutation {
+#     importFeed(url: String!): Boolean! @guard @async(queue: "imports")
+#   }
+#
+# The field must be a Mutation field returning Boolean, and the schema a named
+# constant, which the job looks up.
+class Lighthouse::GraphQL::DirectiveResolvers::AsyncDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'async'
+
+  def self.definition
+    <<~GRAPHQL.chomp
+      """
+      Defer the execution of mutations to queued jobs.
+      The field answers true once the job is queued.
+      """
+      directive @async(
+        "The name of the queue to dispatch the job on."
+        queue: String
+      ) on FIELD_DEFINITION
+    GRAPHQL
+  end
+
+  # What resolves `field` of `type` below @async, for the job to call.
+  def self.inner(type, field)
+    (type.instance_variable_get(:@lighthouse_async_inners) || {}).fetch(field.to_s) do
+      raise Lighthouse::DefinitionError, "#{type.graphql_name}.#{field} has no @async."
+    end
+  end
+
+  def define_resolver(target_type_class)
+    validate!(target_type_class)
+    inner = capture_inner(target_type_class)
+    inners = target_type_class.instance_variable_get(:@lighthouse_async_inners) || {}
+    target_type_class.instance_variable_set(:@lighthouse_async_inners, inners.merge(@field_def.name => inner))
+    me = self
+
+    install(target_type_class, lambda do |_obj, args, ctx|
+      me.enqueue(target_type_class.graphql_name, args, ctx)
+      true
+    end)
+  end
+
+  def enqueue(type_name, args, ctx)
+    schema_name = ctx.schema.name
+    raise Lighthouse::DefinitionError, '@async needs a schema assigned to a constant (AppSchema = ...), for the job to find.' unless schema_name
+
+    job = Lighthouse::GraphQL::AsyncMutationJob
+    job = job.set(queue: directive_arg('queue')) if directive_arg('queue')
+    job.perform_later(schema_name, type_name, @field_def.name, serializable(Lighthouse::Support::Arguments.plain(args)), context_values(ctx))
+  end
+
+  private
+
+  def validate!(target_type_class)
+    return if @opts[:root_kind] == :mutations && @field_def.type.unwrap.graphql_name == 'Boolean'
+
+    raise Lighthouse::DefinitionError,
+          "@async on #{target_type_class.graphql_name}.#{@field_def.name}: only a Mutation field returning Boolean can run in a job."
+  end
+
+  # The context's values ActiveJob can serialize.
+  def context_values(ctx)
+    values = ctx.respond_to?(:to_h) ? ctx.to_h : {}
+    serializable(values.reject { |key, _| key.to_s.start_with?('graphql_', 'lighthouse_') || EXECUTION_KEYS.include?(key) })
+  end
+
+  # graphql-ruby's own context keys, which mean nothing outside the request.
+  EXECUTION_KEYS = %i[current_path current_field current_object current_arguments].freeze
+
+  def serializable(hash)
+    hash.select do |_, value|
+      ::ActiveJob::Arguments.serialize([value])
+      true
+    rescue StandardError
+      false
+    end.transform_keys(&:to_sym)
+  end
+end