lighthouse-graphql 0.4.0 → 0.5.0

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

data/lib/lighthouse/directive_resolvers/base.rb

@@ -12,7 +12,8 @@ class Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
     raise NotImplementedError
   end
 
-  def apply_where_filters(relation, args)
+  # `ctx`: the query's context, for @builder on an argument.
+  def apply_where_filters(relation, args, ctx = nil)
     return relation unless relation.respond_to?(:where)
 
     args_h = args.respond_to?(:to_h) ? args.to_h : (args || {})
@@ -22,7 +23,7 @@ class Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
       relation = apply_where_has_conditions(relation, arg_node, args_h)
     end
 
-    apply_arg_builders(relation, args_h)
+    apply_arg_builders(relation, args_h, ctx)
   rescue ::GraphQL::ExecutionError
     raise
   rescue StandardError => e
@@ -33,16 +34,13 @@ class Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
   # Compose argument-builder directives (@eq, @neq, @in, @notIn, @like,
   # @where, @orderBy) onto the relation, in SDL argument order, for each
   # field argument that carries one and that the client supplied a value
-  # for.
-  def apply_arg_builders(relation, args_h)
+  # for — and for the input fields of an argument carrying @nest.
+  def apply_arg_builders(relation, args_h, ctx = nil)
     return relation unless relation.respond_to?(:where)
     return relation unless @field_def.ast_node
 
-    arg_builders.each do |arg_node, dnode, builder_class|
-      value = Lighthouse::Support::Naming.fetch_arg(args_h, arg_node.name)
-      next if value.nil?
-
-      relation = builder_class.new(arg_node, dnode).handle_builder(relation, value)
+    arg_builders.each do |path, arg_node, dnode, builder_class|
+      relation = apply_arg_builder(relation, args_h, ctx, [path, arg_node, dnode, builder_class])
     end
 
     relation
@@ -136,13 +134,64 @@ class Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
   end
 
   # Every (argument, directive, builder class) on the field, in SDL order.
+  # One argument directive: @builder whenever the client sent the argument,
+  # null included (as PHP Lighthouse's); the others when its value is not null.
+  def apply_arg_builder(relation, args_h, ctx, (path, arg_node, dnode, builder_class))
+    if builder_class == :builder
+      return relation unless arg_present?(args_h, path)
+
+      return Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply_argument(relation, dnode, dig_arg(args_h, path), ctx)
+    end
+
+    value = dig_arg(args_h, path)
+    value.nil? ? relation : builder_class.new(arg_node, dnode).handle_builder(relation, value)
+  end
+
+  # Did the client send the argument at `path`, even as null?
+  def arg_present?(args_h, path)
+    parent = path.size == 1 ? args_h : dig_arg(args_h, path[0...-1])
+    hash = parent.respond_to?(:to_h) && !parent.is_a?(Array) ? parent.to_h : parent
+    hash.is_a?(Hash) && Lighthouse::Support::Naming.candidate_keys(path.last).any? { |key| hash.key?(key) }
+  end
+
+  # [path, node, directive, builder class] for every argument-builder
+  # directive, in SDL order. An argument carrying @nest adds its input type's
+  # fields', at any depth, with their path into the value.
   def arg_builders
-    registry = Lighthouse::DirectiveRegistry.default
     (@field_def.ast_node.arguments || []).flat_map do |arg_node|
-      (arg_node.directives || []).filter_map do |dnode|
-        builder_class = registry.arg_builder_class(dnode.name)
-        [arg_node, dnode, builder_class] if builder_class
-      end
+      builders_of(arg_node, [arg_node.name], @field_def.arguments[arg_node.name])
+    end
+  end
+
+  def builders_of(node, path, argument)
+    registry = Lighthouse::DirectiveRegistry.default
+    own = (node.directives || []).filter_map do |dnode|
+      builder_class = dnode.name == 'builder' ? :builder : registry.arg_builder_class(dnode.name)
+      [path, node, dnode, builder_class] if builder_class
+    end
+    own + (argument && nest?(node) ? nested_builders(argument, path) : [])
+  end
+
+  def nest?(node)
+    (node.directives || []).any? { |d| d.name == 'nest' }
+  end
+
+  def nested_builders(argument, path)
+    type = argument.type.unwrap
+    return [] unless type.kind.input_object?
+
+    type.arguments.each_value.flat_map do |field|
+      field.ast_node ? builders_of(field.ast_node, path + [field.ast_node.name], field) : []
+    end
+  end
+
+  # The client's value at `path` (an argument, then input fields), or nil.
+  def dig_arg(args_h, path)
+    path.reduce(args_h) do |value, name|
+      hash = value.respond_to?(:to_h) && !value.is_a?(Array) ? value.to_h : value
+      break nil unless hash.is_a?(Hash)
+
+      Lighthouse::Support::Naming.fetch_arg(hash, name)
     end
   end
 end

data/lib/lighthouse/directive_resolvers/builder_applier.rb

@@ -2,39 +2,99 @@
 
 require_relative 'base'
 
+# The field-level query directives, in SDL order: @builder classes, and
+# @whereAuth, which keeps the records the signed-in user owns. @builder on an
+# argument is applied with the other argument directives (apply_argument).
+#
+# A builder is `class:` and `method:` (default `call`), or PHP Lighthouse's
+# `method: "Class@method"`, looked up in Config.namespaces[:builders]. It gets
+# the relation, a second value and the context, and returns the relation:
+#
+#   on a field                 (relation, args, context), or the directive's `value:` instead of args
+#   on an argument             (relation, the argument's value, context), whenever the client sends
+#                              the argument, null included
 class Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier
-  DEFINITION = 'directive @builder(class: String!, method: String) repeatable on FIELD_DEFINITION'
+  DEFINITION = <<~GRAPHQL.chomp
+    """
+    Manipulate the query builder with a method.
+    """
+    directive @builder(
+      "The builder class, in the builders namespace."
+      class: String
+      "The method to call: a name (default `call`), or a class and a method separated by `@`."
+      method: String
+      "On a field, the value the method gets after the relation, instead of the arguments."
+      value: BuilderValue
+    ) repeatable on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION | FIELD_DEFINITION
+  GRAPHQL
+
+  TYPE_DEFINITIONS = {
+    'BuilderValue' => <<~GRAPHQL.chomp
+      "Any constant literal value: https://graphql.github.io/graphql-spec/draft/#sec-Input-Values"
+      scalar BuilderValue
+    GRAPHQL
+  }.freeze
+
+  WHERE_AUTH_DEFINITION = <<~GRAPHQL.chomp
+    """
+    Filter a type to only return instances owned by the current user.
+    """
+    directive @whereAuth(
+      "The relation of the model that links it to the user: a belongs_to, a has_many, a :through."
+      relation: String!
+      "Accepted for PHP Lighthouse parity: the user is Config.authenticated_user's."
+      guards: [String!]
+    ) on FIELD_DEFINITION
+  GRAPHQL
+
+  DEFINITIONS = { 'builder' => DEFINITION, 'whereAuth' => WHERE_AUTH_DEFINITION }.freeze
 
   def self.apply(relation, field_def_ast_node, args, ctx, resolver_instance)
     return relation unless field_def_ast_node&.directives
 
-    builder_directives = field_def_ast_node.directives.select { |d| d.name == 'builder' }
-    return relation if builder_directives.empty?
-
-    builder_directives.each do |directive_node|
-      relation = apply_directive(relation, directive_node, args, ctx, resolver_instance)
+    field_def_ast_node.directives.each do |directive_node|
+      case directive_node.name
+      when 'builder' then relation = apply_directive(relation, directive_node, args, ctx, resolver_instance)
+      when 'whereAuth' then relation = where_auth(relation, directive_node, ctx)
+      end
     end
 
     relation
   end
 
+  # The records whose `relation:` links them to the signed-in user; none for a guest.
+  def self.where_auth(relation, directive_node, ctx)
+    user = Lighthouse::Support::Authorization.authenticated_user(ctx)
+    return relation.none unless user
+
+    model = relation.klass
+    name = extract_directive_arg(directive_node, 'relation').to_sym
+    reflection = model.reflect_on_association(name)
+    raise Lighthouse::DefinitionError, "@whereAuth: #{model} has no relation #{name}." unless reflection
+    return relation.where(name => user) if reflection.belongs_to?
+
+    owned = model.unscoped.joins(name).where(reflection.klass.table_name => { reflection.klass.primary_key => user.id })
+    relation.where(model.primary_key => owned.select(model.arel_table[model.primary_key]))
+  end
+
   def self.apply_directive(relation, directive_node, args, ctx, _resolver_instance)
-    class_name = extract_directive_arg(directive_node, 'class')
-    method_name = extract_directive_arg(directive_node, 'method') || 'call'
+    value = directive_node.arguments&.any? { |a| a.name == 'value' } ? extract_directive_arg(directive_node, 'value') : args
+    call_builder(relation, directive_node, value, ctx)
+  end
 
-    return relation unless class_name
+  # @builder on an argument the client sent: the method gets its value.
+  def self.apply_argument(relation, directive_node, value, ctx)
+    call_builder(relation, directive_node, value, ctx)
+  end
 
-    # Builders are not resolvers: they compose onto a relation, and live in
-    # their own namespace (Config.namespaces[:builders], app/graphql/builders).
-    builder_class = Lighthouse::Support::ModelResolver.constantize(
-      class_name, namespaces: Lighthouse::Config.namespaces[:builders]
-    )
+  def self.call_builder(relation, directive_node, value, ctx)
+    builder_class, method_name = reference(directive_node)
     return relation unless builder_class
 
     receiver = builder_receiver(builder_class, method_name)
     return relation unless receiver
 
-    receiver.public_send(method_name, relation, args, ctx) || relation
+    receiver.public_send(method_name, relation, value, ctx) || relation
   rescue ::GraphQL::ExecutionError
     # Client-facing errors (e.g. authorization / scoping guards raised by a
     # builder) MUST propagate — never silently fall back to the unscoped
@@ -45,11 +105,21 @@ class Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier
     relation
   end
 
-  def self.extract_directive_arg(directive_node, name)
-    arg = directive_node.arguments&.find { |a| a.name == name }
-    return nil unless arg
+  # [builder class, method name] from `class:` and `method:`, or from
+  # `method: "Class@method"`. Builders are not resolvers: they live in their
+  # own namespace (Config.namespaces[:builders], app/graphql/builders).
+  def self.reference(directive_node)
+    class_name = extract_directive_arg(directive_node, 'class')
+    method_name = extract_directive_arg(directive_node, 'method')
+    class_name, method_name = method_name.to_s.split('@', 2) if class_name.nil? && method_name
+    return [nil, nil] unless class_name
+
+    builder_class = Lighthouse::Support::ModelResolver.constantize(class_name, namespaces: Lighthouse::Config.namespaces[:builders])
+    [builder_class, method_name.presence || 'call']
+  end
 
-    arg.value.respond_to?(:value) ? arg.value.value : arg.value
+  def self.extract_directive_arg(directive_node, name)
+    Lighthouse::Support::DirectiveArgs.literal(directive_node, name)
   end
 
   # What answers the builder method: the class itself, else an instance

data/lib/lighthouse/directive_resolvers/can_resolvers.rb

@@ -136,7 +136,7 @@ module Lighthouse::GraphQL::DirectiveResolvers
 
     # The records the field's argument filters (@eq, @where, ...) select.
     def authorize_before(_obj, args, ctx)
-      authorize_each!(ctx, apply_where_filters(scoped(model_class.all), args).to_a, args)
+      authorize_each!(ctx, apply_where_filters(scoped(model_class.all), args, ctx).to_a, args)
     end
   end
 

data/lib/lighthouse/directive_resolvers/convention_resolver.rb

@@ -18,6 +18,7 @@ class Lighthouse::GraphQL::DirectiveResolvers::ConventionResolver < Lighthouse::
   end
 
   def define_resolver(target_type_class)
+    Lighthouse::GraphQL::ResolveInfo.request_lookahead(@field_def)
     me = self
     inner = capture_inner(target_type_class)
 
@@ -54,7 +55,7 @@ class Lighthouse::GraphQL::DirectiveResolvers::ConventionResolver < Lighthouse::
     end
     Lighthouse::GraphQL::ResolverBases.check!(klass, @base, location)
 
-    Lighthouse::GraphQL::ResolverDispatch.call(klass, @field_def, obj, args, ctx)
+    Lighthouse::GraphQL::ResolverDispatch.call(klass, Lighthouse::GraphQL::ResolveInfo.for(@field_def, @type_def, obj, args, ctx))
   end
 
   # No class: the root object may still answer (a custom root_value);

data/lib/lighthouse/directive_resolvers/count_resolver.rb

@@ -44,7 +44,7 @@ class Lighthouse::GraphQL::DirectiveResolvers::CountDirectiveResolver < Lighthou
     args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
     relation = apply_scopes(relation)
     relation = Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply(relation, @field_def.ast_node, args_h, ctx, self)
-    relation = apply_where_filters(relation, args_h)
+    relation = apply_where_filters(relation, args_h, ctx)
     relation.count
   end
 end

data/lib/lighthouse/directive_resolvers/field_resolver.rb

@@ -4,21 +4,49 @@ require_relative 'base'
 
 class Lighthouse::GraphQL::DirectiveResolvers::FieldDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
   def self.directive_name = 'field'
-  def self.definition = 'directive @field(resolver: String, class: String) on FIELD_DEFINITION'
 
-  # On Query and Mutation the class is looked up in the queries / mutations
-  # namespaces; on any other type, in Config.resolver_namespaces.
+  def self.definition
+    <<~GRAPHQL.chomp
+      """
+      Assign a resolver to a field: a class, or a class and a method separated by `@`
+      ("Statistics@users_total"). Without a method, the class resolves, or is called.
+      """
+      directive @field(resolver: String, class: String) on FIELD_DEFINITION
+    GRAPHQL
+  end
+
+  # ["Statistics", "users_total"] for "Statistics@users_total"; [name, nil] without `@`.
+  def self.reference(resolver)
+    class_name, method = resolver.to_s.split('@', 2)
+    [class_name, method.presence]
+  end
+
+  # The class @field names. On Query and Mutation (`kind` :queries / :mutations)
+  # it is looked up in that kind's namespaces, nested names included
+  # (`Feeds::Home` is Resolvers::Feeds::Home), then as written. On any other
+  # type, in the resolvers namespace first (`Posts::TagsCount` is
+  # Resolvers::Posts::TagsCount), then in Config.resolver_namespaces. Looked up
+  # at call time, so code reloading keeps working.
+  def self.lookup(class_name, kind)
+    resolver = Lighthouse::Support::ModelResolver
+    return resolver.constantize(class_name, namespaces: Lighthouse::Config.namespaces[kind], nested: true) if kind
+
+    resolver.constantize(class_name, namespaces: Lighthouse::Config.namespaces[:queries], nested: true, fallback: false) ||
+      resolver.constantize(class_name, namespaces: Lighthouse::Config.resolver_namespaces)
+  end
+
   def define_resolver(target_type_class)
+    Lighthouse::GraphQL::ResolveInfo.request_lookahead(@field_def)
     field_def = @field_def
-    class_name = extract_directive_arg('resolver') || extract_directive_arg('class')
+    class_name, method = self.class.reference(extract_directive_arg('resolver') || extract_directive_arg('class'))
     kind = root_kind(target_type_class)
 
     install(target_type_class, lambda do |obj, args, ctx|
-      namespaces = kind ? Lighthouse::Config.namespaces[kind] : Lighthouse::Config.resolver_namespaces
-      klass = Lighthouse::Support::ModelResolver.constantize(class_name, namespaces: namespaces)
+      klass = Lighthouse::GraphQL::DirectiveResolvers::FieldDirectiveResolver.lookup(class_name, kind)
       next nil unless klass
 
-      Lighthouse::GraphQL::ResolverDispatch.call(klass, field_def, obj, args, ctx)
+      info = Lighthouse::GraphQL::ResolveInfo.for(field_def, target_type_class, obj, args, ctx)
+      Lighthouse::GraphQL::ResolverDispatch.call(klass, info, method: method)
     end)
   end