lighthouse-graphql 0.3.0 → 0.5.0

data/lib/lighthouse/directives/model_directive.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+# @model(class: "Post") — map an object type to the ActiveRecord model whose
+# records it resolves, as PHP Lighthouse's directive, for when the type's name
+# is not the model's:
+#
+#   type Article @model(class: "Post") { id: ID! title: String! }
+#
+#   type Query {
+#     articles: [Article!]! @paginate      # pages through Post
+#     article(id: ID! @eq): Article @find   # Post.find_by(id:)
+#   }
+#
+# - Every directive that takes `model:` (@all, @find, @first, @paginate, @create,
+#   @update, @upsert, @delete, @can*, ...) on a field returning the type gets it,
+#   unless it names its own: the SDL is rewritten before the schema is built.
+# - A union or interface resolves a record of the model to the type.
+# - @node finds the type's records in the model.
+# - The schema does not build unless the class is an ActiveRecord model, and a
+#   type class's methods (Types::ArticleType) only run on its records.
+class Lighthouse::GraphQL::Directives::ModelDirective
+  DEFINITIONS = {
+    'model' => <<~GRAPHQL.chomp
+      """
+      Map a model class to an object type.
+      This can be used when the name of the model differs from the name of the type.
+      """
+      directive @model(
+        "The class name of the corresponding model."
+        class: String!
+      ) on OBJECT
+    GRAPHQL
+  }.freeze
+
+  OBJECTS = [::GraphQL::Language::Nodes::ObjectTypeDefinition, ::GraphQL::Language::Nodes::ObjectTypeExtension].freeze
+
+  DECLARATION = /directive\s+@model\b/
+  USAGE = /@model\b/
+
+  def self.manipulate(sdl)
+    return sdl unless sdl.is_a?(String) && sdl.gsub(DECLARATION, '').match?(USAGE)
+
+    new(::GraphQL::Language::Parser.parse(sdl)).manipulate(sdl)
+  rescue ::GraphQL::ParseError
+    sdl
+  end
+
+  # The model class name a schema type maps to with @model, or nil.
+  def self.class_name(type)
+    directive = (type.ast_node&.directives || []).find { |d| d.name == 'model' }
+    directive && Lighthouse::Support::DirectiveArgs.literal(directive, 'class')
+  end
+
+  # The model of a schema type: the one @model names, else the one named after it.
+  def self.model_for(type)
+    Lighthouse::Support::ModelResolver.constantize(class_name(type) || type.graphql_name)
+  end
+
+  # The model @model declares on a schema type, or nil.
+  def self.declared_model(type)
+    name = class_name(type)
+    name && Lighthouse::Support::ModelResolver.constantize(name)
+  end
+
+  # Fail at build time: every @model names an ActiveRecord model.
+  def self.validate!(schema)
+    schema.types.each_value do |type|
+      name = type.kind.object? && class_name(type)
+      next unless name
+
+      model = declared_model(type)
+      next if model.is_a?(Class) && defined?(::ActiveRecord::Base) && model < ::ActiveRecord::Base
+
+      raise Lighthouse::DefinitionError, "@model(class: #{name.inspect}) on #{type.graphql_name} names no ActiveRecord model."
+    end
+  end
+
+  # The directives that take `model:` and act on a field, from the registry.
+  def self.model_directives
+    Lighthouse::DirectiveRegistry.default.directive_definitions
+                                 .select { |_, definition| definition.match?(/\bmodel:/) && definition.include?('FIELD_DEFINITION') }.keys
+  end
+
+  def initialize(document)
+    @document = document
+    @models = document.definitions.filter_map { |definition| [definition.name, model_name(definition)] if object?(definition) }
+                      .select(&:last).to_h
+    @directives = self.class.model_directives
+  end
+
+  def manipulate(sdl)
+    return sdl if @models.empty?
+
+    definitions = @document.definitions.map { |definition| object?(definition) ? with_models(definition) : definition }
+    ::GraphQL::Language::Printer.new.print(@document.merge(definitions: definitions))
+  end
+
+  private
+
+  def object?(definition)
+    OBJECTS.any? { |kind| definition.is_a?(kind) }
+  end
+
+  # The class @model names on a type definition, or nil.
+  def model_name(definition)
+    directive = definition.directives.find { |d| d.name == 'model' }
+    directive&.arguments&.find { |argument| argument.name == 'class' }&.value
+  end
+
+  def with_models(definition)
+    definition.merge(fields: definition.fields.map { |field| with_model(field) })
+  end
+
+  # The field's model directives with `model:` set to the model its return type maps to.
+  def with_model(field)
+    model = @models[unwrap(field.type).name]
+    return field unless model
+
+    field.merge(directives: field.directives.map { |directive| with_model_argument(directive, model) })
+  end
+
+  def with_model_argument(directive, model)
+    return directive unless @directives.include?(directive.name) && directive.arguments.none? { |argument| argument.name == 'model' }
+
+    directive.merge(arguments: directive.arguments + [::GraphQL::Language::Nodes::Argument.new(name: 'model', value: model)])
+  end
+
+  def unwrap(type)
+    type.respond_to?(:of_type) ? unwrap(type.of_type) : type
+  end
+end

data/lib/lighthouse/directives/node_directive.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+# @node — Relay's global object identification, as PHP Lighthouse's directive.
+# On a type, it makes the schema:
+#
+#   "Any object implementing this type can be found by ID through `Query.node`."
+#   interface Node @interface(resolveType: "Lighthouse::GraphQL::NodeRegistry") {
+#     "Global identifier that can be used to resolve any Node implementation."
+#     id: ID!
+#   }
+#
+#   type User implements Node @node { id: ID! @globalId ... }
+#
+#   type Query {
+#     node(id: ID! @globalId): Node @field(resolver: "Lighthouse::GraphQL::NodeRegistry@resolve")
+#   }
+#
+# leaving alone what the SDL declares itself (a Node interface, a Query.node
+# field, with its own description or middleware). The type keeps its own
+# `id: ID! @globalId`, which encodes the ids `node` decodes. NodeRegistry finds
+# the record: through the type's `model:` or model, or its `resolver:`.
+class Lighthouse::GraphQL::Directives::NodeDirective
+  DEFINITIONS = {
+    'node' => <<~GRAPHQL.chomp
+      """
+      Register a type for Relay's global object identification.
+
+      When used without any arguments, Lighthouse will attempt
+      to resolve the type through a model with the same name.
+      """
+      directive @node(
+        """
+        Reference to a class (and method, after `@`) that receives the decoded `id`
+        and the context, and returns the object.
+
+        Mutually exclusive with `model`.
+        """
+        resolver: String
+
+        """
+        Specify the class name of the model to use.
+        This is only needed when the default model detection does not work.
+
+        Mutually exclusive with `resolver`.
+        """
+        model: String
+      ) on OBJECT
+    GRAPHQL
+  }.freeze
+
+  INTERFACE = <<~GRAPHQL.chomp
+    "Any object implementing this type can be found by ID through `Query.node`."
+    interface Node @interface(resolveType: "Lighthouse::GraphQL::NodeRegistry") {
+      "Global identifier that can be used to resolve any Node implementation."
+      id: ID!
+    }
+  GRAPHQL
+
+  NODE_FIELD = <<~GRAPHQL.chomp
+    type Query {
+      "Fetches an object given its globally unique `ID`."
+      node(id: ID! @globalId): Node @field(resolver: "Lighthouse::GraphQL::NodeRegistry@resolve")
+    }
+  GRAPHQL
+
+  OBJECTS = [::GraphQL::Language::Nodes::ObjectTypeDefinition, ::GraphQL::Language::Nodes::ObjectTypeExtension].freeze
+
+  DECLARATION = /directive\s+@node\b/
+  USAGE = /@node\b/
+
+  def self.manipulate(sdl)
+    return sdl unless sdl.is_a?(String) && sdl.gsub(DECLARATION, '').match?(USAGE)
+
+    new(::GraphQL::Language::Parser.parse(sdl)).manipulate(sdl)
+  rescue ::GraphQL::ParseError
+    sdl
+  end
+
+  def initialize(document)
+    @document = document
+  end
+
+  def manipulate(sdl)
+    return sdl unless @document.definitions.any? { |definition| node?(definition) }
+
+    definitions = @document.definitions.map { |definition| node?(definition) ? implement_node(definition) : definition }
+    definitions = with_node_field(definitions)
+    printed = ::GraphQL::Language::Printer.new.print(@document.merge(definitions: definitions))
+    printed = "#{printed}\n\n#{INTERFACE}" unless declared?('Node')
+    # The added @globalId, @field and @interface need their definitions too.
+    Lighthouse::GraphQL::SchemaGenerator.inject_directive_definitions(printed)
+  end
+
+  private
+
+  def node?(definition)
+    OBJECTS.any? { |kind| definition.is_a?(kind) } && definition.directives.any? { |directive| directive.name == 'node' }
+  end
+
+  def implement_node(definition)
+    return definition if definition.interfaces.any? { |interface| interface.name == 'Node' }
+
+    definition.merge(interfaces: definition.interfaces + [::GraphQL::Language::Nodes::TypeName.new(name: 'Node')])
+  end
+
+  # Query gains `node`, unless a Query definition or extension has one. With
+  # no Query at all, the schema gets one with `node` alone.
+  def with_node_field(definitions)
+    queries = definitions.select { |definition| query?(definition) }
+    return definitions if queries.any? { |query| node_field?(query) }
+
+    node_query = ::GraphQL::Language::Parser.parse(NODE_FIELD).definitions.first
+    return definitions + [node_query] if queries.empty?
+
+    definitions.map { |definition| definition.equal?(queries.first) ? definition.merge(fields: definition.fields + node_query.fields) : definition }
+  end
+
+  def node_field?(query)
+    query.fields.any? { |field| field.name == 'node' }
+  end
+
+  def query?(definition)
+    OBJECTS.any? { |kind| definition.is_a?(kind) } && definition.name == query_name
+  end
+
+  def query_name
+    schema = @document.definitions.find { |definition| definition.is_a?(::GraphQL::Language::Nodes::SchemaDefinition) }
+    schema&.query || 'Query'
+  end
+
+  def declared?(name)
+    @document.definitions.any? { |definition| definition.respond_to?(:name) && definition.name == name && !definition.is_a?(::GraphQL::Language::Nodes::ObjectTypeExtension) }
+  end
+end

data/lib/lighthouse/directives/pagination_manipulator.rb

@@ -16,7 +16,7 @@ require_relative 'pagination_info_types'
 # relation directive (no `type:`) and @all keep returning the list.
 # The runtime side is Lighthouse::GraphQL::Pagination.
 class Lighthouse::GraphQL::Directives::PaginationManipulator
-  RELATION_DIRECTIVES = %w[hasMany belongsToMany morphMany morphToMany].freeze
+  RELATION_DIRECTIVES = %w[hasMany hasManyThrough belongsToMany morphMany morphToMany].freeze
   OBJECT_DEFINITIONS = [
     ::GraphQL::Language::Nodes::ObjectTypeDefinition,
     ::GraphQL::Language::Nodes::ObjectTypeExtension

data/lib/lighthouse/directives/registry.rb

@@ -61,13 +61,17 @@ class Lighthouse::DirectiveRegistry
   # authorization, argument validation, then @cache (so a cache hit is still
   # authorized and validated), @clearCache (which acts once the resolver
   # succeeded), @event and @broadcast (likewise), and finally the data resolver (0).
+  # @throttle counts every call, before anything else runs; @async queues what is
+  # below @cache, once the request has authorized and validated the call.
   RESOLUTION_ORDER = {
+    'throttle' => 7,
     'convertEmptyStringsToNull' => 6,
     'guard' => 5, 'auth' => 5,
     'canFind' => 4, 'canModel' => 4, 'canQuery' => 4, 'canResolved' => 4, 'canRoot' => 4,
     'validator' => 3,
-    'cache' => 2,
-    'clearCache' => 1, 'event' => 1, 'broadcast' => 1
+    'cache' => 2, 'async' => 2,
+    'clearCache' => 1, 'event' => 1, 'broadcast' => 1,
+    'with' => 1, 'withCount' => 1, 'lazyLoad' => 1, 'globalId' => 1
   }.freeze
 
   def resolution_order(name)
@@ -164,6 +168,8 @@ class Lighthouse::DirectiveRegistry
     'rename' => :RenameDirectiveResolver,
     'method' => :MethodDirectiveResolver,
     'auth' => :AuthDirectiveResolver,
+    'hasManyThrough' => :HasManyDirectiveResolver,
+    'hasOneThrough' => :HasOneDirectiveResolver,
     'guard' => :GuardDirectiveResolver
   }.freeze
 
@@ -181,17 +187,15 @@ class Lighthouse::DirectiveRegistry
     CacheDirectiveResolver ClearCacheDirectiveResolver EventDirectiveResolver
     ValidatorDirectiveResolver ConvertEmptyStringsToNullDirectiveResolver
     SubscriptionDirectiveResolver BroadcastDirectiveResolver
+    WithDirectiveResolver WithCountDirectiveResolver LazyLoadDirectiveResolver
+    GlobalIdDirectiveResolver NamespacedDirectiveResolver ThrottleDirectiveResolver AsyncDirectiveResolver
   ].freeze
 
   # Argument-builder filter/sort directives.
-  ARG_BUILDERS = %i[Eq Neq In NotIn Like Where WhereKey OrderBy Trashed WithoutGlobalScopes].freeze
-
-  # Read by other directives rather than resolving anything themselves.
-  PASSIVE_DEFINITIONS = {
-    'spread' => 'directive @spread on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION',
-    'inject' => 'directive @inject(context: String!, name: String!) repeatable on FIELD_DEFINITION',
-    'cacheKey' => 'directive @cacheKey on FIELD_DEFINITION'
-  }.freeze
+  ARG_BUILDERS = %i[
+    Eq Neq In NotIn Like Where WhereKey OrderBy Trashed WithoutGlobalScopes
+    WhereNull WhereNotNull WhereBetween WhereNotBetween WhereJsonContains Scope Limit
+  ].freeze
 
   def register_defaults
     resolvers = Lighthouse::GraphQL::DirectiveResolvers
@@ -200,9 +204,14 @@ class Lighthouse::DirectiveRegistry
     ARG_BUILDERS.each { |constant| register(Lighthouse::GraphQL::Directives::Arguments.const_get(constant, false)) }
 
     # SDL manipulators run in registration order during the manipulation phase.
+    # @hide / @show first, so a removed field generates nothing; then @model,
+    # which names the model of fields @paginate then rewrites.
+    register_manipulator(Lighthouse::GraphQL::Directives::VisibilityDirective)
+    register_manipulator(Lighthouse::GraphQL::Directives::ModelDirective)
     register_manipulator(Lighthouse::GraphQL::Directives::PaginationManipulator)
     register_manipulator(Lighthouse::GraphQL::Directives::WhereConditionsDirective)
     register_manipulator(Lighthouse::GraphQL::Directives::SoftDeletesDirective)
+    register_manipulator(Lighthouse::GraphQL::Directives::NodeDirective)
 
     register_default_definitions
     self
@@ -213,16 +222,8 @@ class Lighthouse::DirectiveRegistry
   # SDL of the directives (and the types they refer to) that no registered
   # class contributes.
   def register_default_definitions
-    register_definition('builder', Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier::DEFINITION)
-    PASSIVE_DEFINITIONS.each { |name, definition| register_definition(name, definition) }
-    register_definition('cacheControl', Lighthouse::GraphQL::CacheControl::DEFINITION)
-    Lighthouse::GraphQL::CacheControl::TYPE_DEFINITIONS.each { |name, sdl| register_type_definition(name, sdl) }
-    register_definition('feature', Lighthouse::GraphQL::FeatureDirective::DEFINITION)
-    Lighthouse::GraphQL::FeatureDirective::TYPE_DEFINITIONS.each { |name, sdl| register_type_definition(name, sdl) }
-    Lighthouse::GraphQL::Directives::WhereConditionsDirective::DEFINITIONS.each do |name, definition|
-      register_definition(name, definition)
-    end
-    Lighthouse::GraphQL::Directives::SoftDeletesDirective::DEFINITIONS.each { |name, definition| register_definition(name, definition) }
+    Lighthouse::GraphQL::Directives::Definitions.directives.each { |name, definition| register_definition(name, definition) }
+    Lighthouse::GraphQL::Directives::Definitions.types.each { |name, sdl| register_type_definition(name, sdl) }
   end
 
   def safe_definition(klass)

data/lib/lighthouse/directives/visibility_directive.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# @hide(env:) and @show(env:) — leave a field out of the schema in some
+# environments, as PHP Lighthouse's directives: @hide removes it in the ones
+# listed, @show keeps it only in those. The environment is Rails.env (see
+# Support::Environment); the SDL is rewritten before the schema is built.
+#
+#   type Query {
+#     debugInfo: String @show(env: ["development", "test"])
+#     legacyFeed: [Post!]! @hide(env: ["production"]) @all
+#   }
+class Lighthouse::GraphQL::Directives::VisibilityDirective
+  DEFINITIONS = {
+    'hide' => <<~GRAPHQL.chomp,
+      """
+      Excludes the annotated element from the schema conditionally.
+      """
+      directive @hide(
+        "Specify which environments must not use this field, e.g. [\\"production\\"]."
+        env: [String!]!
+      ) on FIELD_DEFINITION
+    GRAPHQL
+    'show' => <<~GRAPHQL.chomp
+      """
+      Includes the annotated element in the schema conditionally.
+      """
+      directive @show(
+        "Specify which environments may use this field, e.g. [\\"testing\\"]."
+        env: [String!]!
+      ) on FIELD_DEFINITION
+    GRAPHQL
+  }.freeze
+
+  FIELDS = [
+    ::GraphQL::Language::Nodes::ObjectTypeDefinition, ::GraphQL::Language::Nodes::ObjectTypeExtension,
+    ::GraphQL::Language::Nodes::InterfaceTypeDefinition, ::GraphQL::Language::Nodes::InterfaceTypeExtension
+  ].freeze
+
+  DECLARATION = /directive\s+@(hide|show)\b/
+  USAGE = /@(hide|show)\b/
+
+  def self.manipulate(sdl)
+    return sdl unless sdl.is_a?(String) && sdl.gsub(DECLARATION, '').match?(USAGE)
+
+    document = ::GraphQL::Language::Parser.parse(sdl)
+    env = Lighthouse::Support::Environment.current
+    ::GraphQL::Language::Printer.new.print(document.merge(definitions: document.definitions.map { |definition| visible_fields(definition, env) }))
+  rescue ::GraphQL::ParseError
+    sdl
+  end
+
+  def self.visible_fields(definition, env)
+    return definition unless FIELDS.any? { |kind| definition.is_a?(kind) }
+
+    definition.merge(fields: definition.fields.select { |field| visible?(field, env) })
+  end
+
+  def self.visible?(field, env)
+    field.directives.all? do |directive|
+      case directive.name
+      when 'hide' then environments(directive).exclude?(env)
+      when 'show' then environments(directive).include?(env)
+      else true
+      end
+    end
+  end
+
+  def self.environments(directive)
+    Array(directive.arguments.find { |argument| argument.name == 'env' }&.value).map(&:to_s)
+  end
+end

data/lib/lighthouse/enum_directive.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# @enum(value:) — the internal value of an enum value, as PHP Lighthouse's
+# directive: what a resolver gets for it in an argument, and what it answers
+# with in a result.
+#
+#   enum Role {
+#     ADMIN @enum(value: "admin")
+#     MEMBER @enum(value: "member")
+#   }
+#
+# `users(role: Role @eq)` then filters on "admin", and a User whose role is
+# "admin" answers ADMIN. Without the directive, a value is its own name.
+module Lighthouse::GraphQL::EnumDirective
+  DEFINITION = <<~GRAPHQL.chomp
+    """
+    Assign an internal value to an enum key.
+    When dealing with the Enum type in your code,
+    you will receive the defined value instead of the string key.
+    """
+    directive @enum(
+      "The internal value of the enum key."
+      value: Mixed
+    ) on ENUM_VALUE
+  GRAPHQL
+
+  TYPE_DEFINITIONS = { 'Mixed' => 'scalar Mixed' }.freeze
+
+  module_function
+
+  def apply(schema)
+    schema.types.each_value { |type| apply_to(type) if type.kind.enum? }
+  end
+
+  def apply_to(enum_type)
+    enum_type.values.each_value do |enum_value|
+      directive = (enum_value.ast_node&.directives || []).find { |d| d.name == 'enum' }
+      enum_value.value(Lighthouse::Support::DirectiveArgs.literal(directive, 'value')) if directive
+    end
+  end
+end

data/lib/lighthouse/events/execution_trace.rb

@@ -33,7 +33,8 @@ module Lighthouse::Events::ExecutionTrace
       result = query.result_values
       return unless result.is_a?(Hash)
 
-      merge_extensions(result, Lighthouse::Events.dispatch(Lighthouse::Events::BuildExtensionsResponse.new(result, nil)))
+      complexity = Lighthouse::GraphQL::Complexity.query_complexity(query)
+      merge_extensions(result, Lighthouse::Events.dispatch(Lighthouse::Events::BuildExtensionsResponse.new(result, complexity)))
       manipulate = Lighthouse::Events::ManipulateResult.new(result)
       Lighthouse::Events.dispatch(manipulate)
       result.replace(manipulate.result) unless manipulate.result.equal?(result)

data/lib/lighthouse/events/lifecycle.rb

@@ -71,7 +71,9 @@ module Lighthouse::Events
 
   # A query ran. A listener may return an Events::ExtensionsResponse (or an
   # Array of them), which is merged into the result's "extensions".
-  # `query_complexity` is nil unless it was computed.
+  # `query_complexity` is the query's complexity score, as graphql-ruby checks it
+  # against max_complexity (see GraphQL::Complexity); nil for a query that
+  # failed validation, which is never scored.
   class BuildExtensionsResponse < Event
     attr_reader :result, :query_complexity
 

data/lib/lighthouse/field_resolver_stack.rb

@@ -3,21 +3,27 @@
 # Install a field's resolvers innermost first (see
 # DirectiveRegistry#resolution_order), so each wrapper decorates the ones
 # before it. Besides its directives, a field gets the conventional
-# Queries::/Mutations:: resolver when it is a root field with no resolving
-# directive, and argument validation when an input type it takes carries
-# @validator. The registry replaces a hardcoded `case dnode.name`: adding a
+# Resolvers::/Mutations:: resolver when it is a root field with no resolving
+# directive, the method of the type's class (Types::PostType) when another
+# type's field has none, and argument validation when an input type it takes
+# carries @validator. The registry replaces a hardcoded `case dnode.name`: adding a
 # directive is "register a class", not "edit the generator".
 module Lighthouse::GraphQL::FieldResolverStack
   module_function
 
-  def apply(type, field_def, directives, root_kind)
-    opts = { root_kind: root_kind }
+  # `bases`: { root kind => base class } from the schema's base_types (ResolverBases).
+  # `type_class`: the class of a non-root type (Types::PostType), whose methods
+  # resolve its fields that have no resolving directive.
+  def apply(type, field_def, root_kind, bases: {}, type_class: nil)
+    directives = field_def.ast_node.directives || []
+    opts = { root_kind: root_kind, bases: bases }
     steps = directive_steps(type, field_def, directives, opts)
-    steps << convention_step(type, field_def, root_kind) if root_kind && !resolving_directive?(directives)
+    steps << limit_step(type, field_def, opts) if Lighthouse::GraphQL::DirectiveResolvers::LimitResolver.keyword(field_def)
+    steps << own_step(type, field_def, root_kind, bases, type_class) unless resolving_directive?(directives)
     steps << validator_step(type, field_def, opts) if input_validation?(field_def, directives)
-    steps << empty_strings_step(type, field_def, opts) if empty_string_conversion?(field_def, directives)
+    steps.concat(argument_steps(type, field_def, directives, opts))
 
-    steps.each_with_index.sort_by { |(order, _), index| [order, index] }.each { |(_, step), _| step.call }
+    steps.compact.each_with_index.sort_by { |(order, _), index| [order, index] }.each { |(_, step), _| step.call }
   end
 
   # [order, step] for every directive the registry has a resolver for.
@@ -38,17 +44,33 @@ module Lighthouse::GraphQL::FieldResolverStack
     directives.any? { |d| registry.resolution_class(d.name) && !registry.wrapper?(d.name) }
   end
 
-  def convention_step(type, field_def, root_kind)
+  def convention_step(type, field_def, root_kind, bases = {})
     resolvers = Lighthouse::GraphQL::DirectiveResolvers
     resolver =
       if root_kind == :subscriptions
-        resolvers::SubscriptionDirectiveResolver.new(field_def, type, nil, root_kind: root_kind)
+        resolvers::SubscriptionDirectiveResolver.new(field_def, type, nil, root_kind: root_kind, bases: bases)
       else
-        resolvers::ConventionResolver.new(field_def, type, root_kind)
+        resolvers::ConventionResolver.new(field_def, type, root_kind, bases[root_kind])
       end
     [0, -> { resolver.define_resolver(type) }]
   end
 
+  # What resolves a field with no resolving directive: the conventional class
+  # of a root field, or the method of the type's class. nil: the default reader.
+  def own_step(type, field_def, root_kind, bases, type_class)
+    return convention_step(type, field_def, root_kind, bases) if root_kind
+
+    type_method_step(type, field_def, type_class) if type_class
+  end
+
+  # Nothing to install when the class does not define the field's method: the
+  # field is read off the object.
+  def type_method_step(type, field_def, type_class)
+    resolver = Lighthouse::GraphQL::DirectiveResolvers::TypeMethodResolver
+    method_name = resolver.method_for(type_class, field_def)
+    [0, -> { resolver.new(field_def, type, method_name).define_resolver(type) }] if method_name
+  end
+
   # An explicit @validator on the field already validates its arguments.
   def input_validation?(field_def, directives)
     directives.none? { |d| d.name == 'validator' } &&
@@ -68,6 +90,32 @@ module Lighthouse::GraphQL::FieldResolverStack
       Lighthouse::GraphQL::DirectiveResolvers::ConvertEmptyStringsToNullDirectiveResolver.implicit?(field_def)
   end
 
+  # The steps that change the arguments: empty strings to null and the rewriting
+  # directives (@globalId, @trim, @drop) outermost, so every wrapper sees them;
+  # the effectful ones (@hash, @bind, @upload) once @guard, @can* and @validator
+  # have let the call through (ArgumentTransformsResolver).
+  ARGUMENT_PHASES = { rewrite: 'convertEmptyStringsToNull', effects: 'cache' }.freeze
+
+  def argument_steps(type, field_def, directives, opts)
+    steps = []
+    steps << empty_strings_step(type, field_def, opts) if empty_string_conversion?(field_def, directives)
+    ARGUMENT_PHASES.each do |phase, alongside|
+      next unless Lighthouse::GraphQL::DirectiveResolvers::ArgumentTransformsResolver.transforms?(field_def, phase)
+
+      steps << transforms_step(type, field_def, opts.merge(phase: phase), Lighthouse::DirectiveRegistry.default.resolution_order(alongside))
+    end
+    steps
+  end
+
+  # Around whatever resolves the field, as @lazyLoad: the result is cut to the client's @limit.
+  def limit_step(type, field_def, opts)
+    [1, -> { Lighthouse::GraphQL::DirectiveResolvers::LimitResolver.new(field_def, type, nil, opts).define_resolver(type) }]
+  end
+
+  def transforms_step(type, field_def, opts, order)
+    [order, -> { Lighthouse::GraphQL::DirectiveResolvers::ArgumentTransformsResolver.new(field_def, type, nil, opts).define_resolver(type) }]
+  end
+
   def empty_strings_step(type, field_def, opts)
     resolver = Lighthouse::GraphQL::DirectiveResolvers::ConvertEmptyStringsToNullDirectiveResolver
     [Lighthouse::DirectiveRegistry.default.resolution_order(resolver.directive_name),

data/lib/lighthouse/generated_resolvers.rb

@@ -25,6 +25,7 @@ module Lighthouse::GraphQL::GeneratedResolvers
 
   # Generated resolvers take either (obj, args) or (obj, args, ctx).
   def invoke(resolver, obj, args, ctx)
+    args = take_lookahead(args, ctx)
     return resolver.call(obj, args) if resolver.parameters.length == 2
 
     resolver.call(obj, args, ctx)
@@ -37,13 +38,7 @@ module Lighthouse::GraphQL::GeneratedResolvers
   def install_dispatcher(schema)
     return unless schema.respond_to?(:definition_default_resolve=) && schema.respond_to?(:definition_default_resolve)
 
-    previous_default = schema.definition_default_resolve
-    schema.definition_default_resolve = proc do |type, field, obj, arguments, ctx|
-      resolver = generated_resolver(schema, type, field)
-      next invoke(resolver, obj, arguments, ctx) if resolver
-
-      previous_default.call(type, field, obj, arguments, ctx)
-    end
+    schema.definition_default_resolve = Lighthouse::GraphQL::DefaultResolveDispatcher.new(schema, schema.definition_default_resolve)
   end
 
   # Our generated resolver for `field`, looked up on the schema's own type
@@ -65,6 +60,16 @@ module Lighthouse::GraphQL::GeneratedResolvers
     end
   end
 
+  # The arguments without graphql-ruby's lookahead extra, which a field resolved
+  # by a class asks for (ResolveInfo.request_lookahead): it is kept in the
+  # field's scoped context, for its ResolveInfo, and no wrapper sees it.
+  def take_lookahead(args, ctx)
+    return args unless args.is_a?(Hash) && args[:lookahead].is_a?(::GraphQL::Execution::Lookahead)
+
+    ctx.scoped_set!(Lighthouse::GraphQL::ResolveInfo::LOOKAHEAD, args[:lookahead]) if ctx.respond_to?(:scoped_set!)
+    args.except(:lookahead)
+  end
+
   # GraphQL-Ruby's SDL builder defines `resolve_<field>` methods that call
   # the schema's `definition_default_resolve`. Override `resolve_<field>`
   # to delegate to our generated `resolve_field_<field>` when present, so
@@ -74,7 +79,7 @@ module Lighthouse::GraphQL::GeneratedResolvers
     return unless type.respond_to?(generated)
 
     type.define_singleton_method("resolve_#{field_def.name}") do |obj, arguments, ctx|
-      public_send(generated, obj, arguments, ctx)
+      public_send(generated, obj, Lighthouse::GraphQL::GeneratedResolvers.take_lookahead(arguments, ctx), ctx)
     end
   rescue StandardError
     # ignore override failures