lighthouse-graphql 0.3.0 → 0.5.0

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

@@ -4,17 +4,21 @@ require_relative 'base'
 
 # Resolves a Query or Mutation field that has no resolving directive by
 # convention, as PHP Lighthouse does: `Query.latestPosts` resolves to
-# `Queries::LatestPosts` (a GraphQL::Schema::Resolver), `Mutation.publishPost`
-# to `Mutations::PublishPost` (a GraphQL::Schema::Mutation), looked up in
+# `Resolvers::LatestPosts` (a GraphQL::Schema::Resolver, by graphql-ruby's
+# convention a Resolvers::BaseResolver), `Mutation.publishPost` to
+# `Mutations::PublishPost` (a GraphQL::Schema::Mutation), looked up in
 # Config.namespaces[:queries] / [:mutations] at call time so code reloading
 # keeps working. Not a directive: SchemaGenerator installs it.
 class Lighthouse::GraphQL::DirectiveResolvers::ConventionResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
-  def initialize(field_def, type_def, kind)
+  # `base`: the class the schema's base_types require the class to inherit from.
+  def initialize(field_def, type_def, kind, base = nil)
     super(field_def, type_def, nil)
     @kind = kind
+    @base = base
   end
 
   def define_resolver(target_type_class)
+    Lighthouse::GraphQL::ResolveInfo.request_lookahead(@field_def)
     me = self
     inner = capture_inner(target_type_class)
 
@@ -31,6 +35,12 @@ class Lighthouse::GraphQL::DirectiveResolvers::ConventionResolver < Lighthouse::
     ROOT_KINDS[type.respond_to?(:graphql_name) ? type.graphql_name : type.to_s]
   end
 
+  # The class a root field resolves to, without its namespace: `LatestPosts`
+  # for `latestPosts`.
+  def self.class_name_for(field_def)
+    field_def.name.to_s.camelize
+  end
+
   private
 
   def resolve_by_convention(inner, obj, args, ctx)
@@ -43,8 +53,9 @@ class Lighthouse::GraphQL::DirectiveResolvers::ConventionResolver < Lighthouse::
             "#{klass} resolves #{location}, so it must inherit from GraphQL::Schema::Resolver " \
             '(or GraphQL::Schema::Mutation).'
     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);
@@ -61,7 +72,7 @@ class Lighthouse::GraphQL::DirectiveResolvers::ConventionResolver < Lighthouse::
   end
 
   def class_name
-    @class_name ||= @field_def.name.to_s.camelize
+    @class_name ||= self.class.class_name_for(@field_def)
   end
 
   def location

data/lib/lighthouse/directive_resolvers/convert_empty_strings_resolver.rb

@@ -19,7 +19,7 @@ require_relative 'base'
 # carried the directive.
 #
 # The conversion is a wrapper around the field's resolver (outermost, order
-# 6), so every kind of resolver — directives, @field, Queries::/Mutations::
+# 6), so every kind of resolver — directives, @field, Resolvers::/Mutations::
 # classes, the default reader — and @validator see the converted arguments,
 # and other fields sharing an input type are unaffected. SchemaGenerator
 # installs it too, without the directive on the field, when an argument or

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
 

data/lib/lighthouse/directive_resolvers/first_resolver.rb

@@ -23,7 +23,7 @@ class Lighthouse::GraphQL::DirectiveResolvers::FirstDirectiveResolver < Lighthou
       args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
       relation = resolver_instance.apply_scopes(model_class.all)
       relation = Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply(relation, field_ast_node, args_h, ctx, resolver_instance)
-      relation = resolver_instance.apply_where_filters(relation, args_h)
+      relation = resolver_instance.apply_where_filters(relation, args_h, ctx)
       relation.first
     end
 

data/lib/lighthouse/directive_resolvers/global_id_resolver.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+# @globalId — Relay global ids, as PHP Lighthouse's directive: on a field it
+# encodes the value with the type's name (`id: ID! @globalId` answers
+# "VXNlcjox" for User 1); on an argument or input field it decodes what the
+# client sent (ArgumentTransformsResolver). Config.global_id does the encoding.
+class Lighthouse::GraphQL::DirectiveResolvers::GlobalIdDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  NAME = 'globalId'
+
+  def self.directive_name = NAME
+
+  def self.definition
+    <<~GRAPHQL.chomp
+      """
+      Converts between IDs/types and global IDs.
+
+      When used upon a field, it encodes;
+      when used upon an argument, it decodes.
+      """
+      directive @globalId(
+        """
+        Decoding a global id produces a tuple of `$type` and `$id`.
+        This setting controls which of those is passed along.
+        """
+        decode: GlobalIdDecode = ARRAY
+      ) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION
+    GRAPHQL
+  end
+
+  def self.type_definitions
+    {
+      'GlobalIdDecode' => <<~GRAPHQL.chomp
+        "Options for the `decode` argument of `@globalId`."
+        enum GlobalIdDecode {
+          "Return an array of `[$type, $id]`."
+          ARRAY
+          "Return just `$type`."
+          TYPE
+          "Return just `$id`."
+          ID
+        }
+      GRAPHQL
+    }
+  end
+
+  def define_resolver(target_type_class)
+    inner = capture_inner(target_type_class)
+    type_name = target_type_class.graphql_name
+
+    install(target_type_class, lambda do |obj, args, ctx|
+      id = inner.call(obj, args, ctx)
+      id.nil? ? nil : Lighthouse::Config.global_id.encode(type_name, id)
+    end)
+  end
+end

data/lib/lighthouse/directive_resolvers/lazy_load_resolver.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+# @lazyLoad(relations: ["replies"]) — eager-load relations of the records a field
+# returns, as PHP Lighthouse's @lazyLoad does, so the fields the client selects on
+# them do not query once per record. Works on a list, a relation, and a @paginate
+# page; across every parent in the response at once, so a @hasMany's records for
+# all its parents load their relations together.
+#
+#   type Post {
+#     comments: [Comment!]! @hasMany @lazyLoad(relations: ["replies", "author"])
+#   }
+class Lighthouse::GraphQL::DirectiveResolvers::LazyLoadDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'lazyLoad'
+
+  def self.definition
+    <<~GRAPHQL.chomp
+      """
+      Eager-load relations of the records the field returns.
+      """
+      directive @lazyLoad(
+        "The relations to load, nested with dots."
+        relations: [String!]!
+      ) repeatable on FIELD_DEFINITION
+    GRAPHQL
+  end
+
+  def define_resolver(target_type_class)
+    inner = capture_inner(target_type_class)
+    associations = Lighthouse::Support::Preload.associations(directive_arg('relations'))
+
+    install(target_type_class, lambda do |obj, args, ctx|
+      Lighthouse::GraphQL::DirectiveResolvers::LazyLoadDirectiveResolver.load(inner.call(obj, args, ctx), associations, ctx)
+    end)
+  end
+
+  # `result` with `associations` loaded into its records.
+  def self.load(result, associations, ctx)
+    return result.preload(*associations) if unloaded_relation?(result)
+
+    records = records_of(result).grep(::ActiveRecord::Base)
+    ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::PreloadLoader, associations, []).load_all(records) if records.any?
+    result
+  end
+
+  # A query not run yet takes the preload itself. An association's records (what
+  # @hasMany returns, loaded for every parent at once) or a loaded relation
+  # are records already: they load their relations together, in the Dataloader.
+  def self.unloaded_relation?(result)
+    result.is_a?(::ActiveRecord::Relation) && !result.is_a?(::ActiveRecord::Associations::CollectionProxy) && !result.loaded?
+  end
+
+  def self.records_of(result)
+    case result
+    when Lighthouse::GraphQL::Pagination::LazyPage then result.items
+    when Hash then Array(result['data'] || result[:data])
+    else Array(result)
+    end
+  end
+end

data/lib/lighthouse/directive_resolvers/limit_resolver.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+# @limit on an argument — the client caps how many results the field returns,
+# as PHP Lighthouse's directive: `posts(limit: Int @limit): [Post!]! @all`. The
+# argument must be an Int; null leaves the results alone. A query not run yet
+# gets a LIMIT; a list already loaded (a @hasMany's records, loaded for every
+# parent at once) is cut in memory, so one parent's limit never cuts another's.
+# With `builder: true` it is a LIMIT on the field's query instead, through the
+# argument directives (Arguments::Limit): for root fields, as PHP Lighthouse
+# warns, since a relation batched for many parents would be cut as a whole.
+# PHP Lighthouse also allows @limit on the field, where it marks the field the
+# argument limits; it is accepted there and changes nothing. Not a directive
+# resolver: FieldResolverStack installs it on a field whose arguments carry
+# @limit, around whatever resolves the field.
+class Lighthouse::GraphQL::DirectiveResolvers::LimitResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  # The keyword of the argument whose @limit cuts the results, or nil; every
+  # argument carrying @limit must be an Int.
+  def self.keyword(field_def)
+    limiting = field_def.arguments.each_value.select { |argument| directive(argument) }
+    limiting.each { |argument| validate!(field_def, argument) }
+    limiting.find { |argument| !Lighthouse::Support::DirectiveArgs.literal(directive(argument), 'builder') }&.keyword
+  end
+
+  def self.directive(argument)
+    (argument.ast_node&.directives || []).find { |d| d.name == 'limit' }
+  end
+
+  def self.validate!(field_def, argument)
+    return if argument.type.unwrap.graphql_name == 'Int'
+
+    raise Lighthouse::DefinitionError,
+          "The @limit directive must only be used on arguments of type Int, got #{field_def.name}.#{argument.graphql_name} of type " \
+          "#{argument.type.unwrap.graphql_name}."
+  end
+
+  def define_resolver(target_type_class)
+    keyword = self.class.keyword(@field_def)
+    inner = capture_inner(target_type_class)
+
+    install(target_type_class, lambda do |obj, args, ctx|
+      limit = args.is_a?(Hash) ? args[keyword] : nil
+      result = inner.call(obj, args, ctx)
+      limit.nil? ? result : Lighthouse::GraphQL::DirectiveResolvers::LimitResolver.cut(result, limit)
+    end)
+  end
+
+  def self.cut(result, limit)
+    raise ::GraphQL::ExecutionError, "The limit must be positive, got #{limit}." if limit.negative?
+
+    case result
+    when ::ActiveRecord::Associations::CollectionProxy then result.to_a.first(limit)
+    when ::ActiveRecord::Relation then result.loaded? ? result.to_a.first(limit) : result.limit(limit)
+    when Array then result.first(limit)
+    else result
+    end
+  end
+end

data/lib/lighthouse/directive_resolvers/method_resolver.rb

@@ -8,6 +8,12 @@ require_relative 'base'
 #
 #   labels: [String!]! @method(name: "label_list")
 #   canReply: Boolean   @method(name: "can_reply?")
+#   excerpt(length: Int = 80): String @method
+#
+# The field's arguments reach the method: as snake_case keywords when it takes
+# keywords (`def excerpt(length:)`), else positionally in the order the SDL
+# declares them, as PHP Lighthouse passes them (`def excerpt(length)`). A method
+# taking no parameters is called without them.
 class Lighthouse::GraphQL::DirectiveResolvers::MethodDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
   def self.directive_name = 'method'
   def self.definition = 'directive @method(name: String) on FIELD_DEFINITION'
@@ -17,13 +23,42 @@ class Lighthouse::GraphQL::DirectiveResolvers::MethodDirectiveResolver < Lightho
     target_method = (Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'name') ||
                      Lighthouse::Support::Naming.attribute(@field_def.name)).to_s
 
-    resolver = lambda do |obj, _arguments, _ctx|
-      next nil if obj.nil?
+    field_def = @field_def
+    resolver = lambda do |obj, arguments, ctx|
+      next nil if obj.nil? || !obj.respond_to?(target_method)
 
-      obj.respond_to?(target_method) ? obj.public_send(target_method) : nil
+      Lighthouse::GraphQL::DirectiveResolvers::MethodDirectiveResolver.call_method(obj.method(target_method), field_def, arguments, ctx)
     end
 
     target_type_class.define_singleton_method(resolver_method, &resolver)
     @field_def.resolve_proc = resolver if @field_def.respond_to?(:resolve_proc=)
   end
+
+  KEYWORDS = %i[key keyreq keyrest].freeze
+  NAMED_KEYWORDS = %i[key keyreq].freeze
+
+  # Call `method` with the field's arguments, as the method takes them.
+  def self.call_method(method, field_def, arguments, ctx)
+    params = method.parameters
+    return method.call if field_def.arguments.empty? || params.empty?
+
+    values = Lighthouse::Support::Arguments.prepare(field_def, arguments, ctx)
+    return method.call(**keywords(params, values)) if params.any? { |type, _| KEYWORDS.include?(type) }
+
+    method.call(*positional(params, field_def, values))
+  end
+
+  # The values in the order the SDL declares the arguments, as many as the
+  # method takes; all of them when it takes *rest.
+  def self.positional(params, field_def, values)
+    ordered = field_def.arguments.each_value.map { |arg| values[arg.keyword] }
+    params.any? { |type, _| type == :rest } ? ordered : ordered.first(params.size)
+  end
+
+  # The values the method's keywords name; all of them when it takes **keywords.
+  def self.keywords(params, values)
+    return values if params.any? { |type, _| type == :keyrest }
+
+    values.slice(*params.filter_map { |type, name| name if NAMED_KEYWORDS.include?(type) })
+  end
 end

data/lib/lighthouse/directive_resolvers/model_mutation_resolver.rb

@@ -196,7 +196,7 @@ module Lighthouse::GraphQL::DirectiveResolvers
       args = Lighthouse::Support::Arguments.shallow(args)
       raise ::GraphQL::ExecutionError, WOULD_MODIFY_ALL unless filtered?(args)
 
-      records = apply_where_filters(records_of(model), args).to_a
+      records = apply_where_filters(records_of(model), args, ctx).to_a
       records.each do |record|
         next if modify(record)