lighthouse-graphql 0.4.0 → 0.5.0

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/field_resolver_stack.rb

@@ -4,21 +4,26 @@
 # DirectiveRegistry#resolution_order), so each wrapper decorates the ones
 # before it. Besides its directives, a field gets the conventional
 # Resolvers::/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
+# 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
 
   # `bases`: { root kind => base class } from the schema's base_types (ResolverBases).
-  def apply(type, field_def, directives, root_kind, bases: {})
+  # `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, bases) 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.
@@ -50,6 +55,22 @@ module Lighthouse::GraphQL::FieldResolverStack
     [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' } &&
@@ -69,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

data/lib/lighthouse/global_id.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+# Relay global ids, as PHP Lighthouse's Base64GlobalId writes them: the type
+# name and the id, joined by a colon, in base64 ("User:1" -> "VXNlcjox").
+# Config.global_id takes another object with `encode(type, id)` and
+# `decode(global_id)` -> [type, id], as PHP Lighthouse lets the GlobalId
+# contract be rebound.
+module Lighthouse::GraphQL::GlobalId
+  module_function
+
+  def encode(type, id)
+    Base64.strict_encode64("#{type}:#{id}")
+  end
+
+  def decode(global_id)
+    Base64.strict_decode64(global_id.to_s).split(':', 2)
+  rescue ArgumentError
+    []
+  end
+
+  # [type, id] for a global id a client sent, through Config.global_id; a
+  # GraphQL::ExecutionError when it is not one.
+  def decode!(global_id)
+    type, id = Lighthouse::Config.global_id.decode(global_id)
+    return [type, id] if type.present? && !id.nil?
+
+    raise ::GraphQL::ExecutionError, "#{global_id.inspect} is not a valid global id."
+  end
+end

data/lib/lighthouse/graphql/version.rb

@@ -2,6 +2,6 @@
 
 module Lighthouse
   module GraphQL
-    VERSION = '0.4.0'
+    VERSION = '0.5.0'
   end
 end

data/lib/lighthouse/multipart_request.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'json'
+
+# The GraphQL multipart request specification
+# (https://github.com/jaydenseric/graphql-multipart-request-spec), which file
+# uploads use: a multipart form with `operations` (the JSON operation, or a
+# batch of them), `map` (each file's form key => the paths in `operations` it
+# goes to, e.g. { "0": ["variables.avatar"] }) and the files. The controller
+# concern reads it into the operation(s), with every file in place.
+module Lighthouse::GraphQL::MultipartRequest
+  module_function
+
+  # The operation (a Hash) or batch (an Array), with the files in place; nil
+  # when the request is not a multipart one.
+  def operations(params)
+    raw = param(params, 'operations')
+    return unless raw
+
+    operations = parse(raw)
+    parse(param(params, 'map') || '{}').each do |key, paths|
+      Array(paths).each { |path| place(operations, path.to_s.split('.'), param(params, key)) }
+    end
+    operations
+  end
+
+  def param(params, key)
+    params[key.to_s] || params[key.to_sym]
+  end
+
+  def parse(value)
+    value = value.to_unsafe_h if value.respond_to?(:to_unsafe_h)
+    value.is_a?(String) ? JSON.parse(value) : value
+  end
+
+  def place(target, segments, file)
+    *parents, last = segments
+    container = parents.reduce(target) { |node, segment| node.is_a?(Array) ? node[Integer(segment)] : node[segment] }
+    raise ArgumentError, "The multipart map names a path that is not in the operations: #{segments.join('.')}" unless container
+
+    container.is_a?(Array) ? container[Integer(last)] = file : container[last] = file
+  end
+end

data/lib/lighthouse/node_registry.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# Resolves Relay's `Query.node(id:)`, which @node adds, as PHP Lighthouse's
+# NodeRegistry: the id is decoded into a type and an id, and the type must be
+# one with @node. Its object comes from, in order:
+#
+# - `@node(resolver: "Class@method")`: the class (method `call` without `@`),
+#   looked up as @field looks a class up on a type, called with the id and the
+#   context;
+# - `@node(model: "Name")`, or else the type's @model, or else the model named
+#   after the type:
+#   the record with that primary key, batched across every `node` in the query.
+#
+# It also tells the Node interface which type each object is (resolve_type):
+# `node` hands back the object with the type its id named, so a `resolver:` may
+# return any object, a Hash included, and one record may be two node types.
+class Lighthouse::GraphQL::NodeRegistry
+  # What `node` returns: the object, and the type its global id named.
+  Found = Struct.new(:type, :object)
+
+  def self.resolve(_root, args, context, _info = nil)
+    type_name, id = args[:id]
+    type = context.schema.get_type(type_name.to_s)
+    raise ::GraphQL::ExecutionError, "[#{type_name}] is not a type that can be resolved by node." unless node_type?(type)
+
+    object = find(type, id, context)
+    object.nil? ? nil : Found.new(type, object)
+  end
+
+  # [type, object] for what `node` found; nil leaves any other Node value to the default.
+  def self.resolve_type(object, _context)
+    [object.type, object.object] if object.is_a?(Found)
+  end
+
+  def self.node_type?(type)
+    type&.kind&.object? && !directive(type).nil?
+  end
+
+  def self.directive(type)
+    (type.ast_node&.directives || []).find { |d| d.name == 'node' }
+  end
+
+  def self.find(type, id, context)
+    node = directive(type)
+    resolver = Lighthouse::Support::DirectiveArgs.literal(node, 'resolver')
+    return call_resolver(resolver, id, context) if resolver
+
+    model = model_for(type, Lighthouse::Support::DirectiveArgs.literal(node, 'model'))
+    raise Lighthouse::DefinitionError, "@node on #{type.graphql_name} finds no model: give it model: or resolver:." unless model
+
+    context.dataloader.with(::GraphQL::Dataloader::ActiveRecordSource, model).load(model.type_for_attribute(model.primary_key).cast(id))
+  end
+
+  def self.call_resolver(reference, id, context)
+    class_name, method = Lighthouse::GraphQL::DirectiveResolvers::FieldDirectiveResolver.reference(reference)
+    klass = Lighthouse::GraphQL::DirectiveResolvers::FieldDirectiveResolver.lookup(class_name, nil)
+    raise Lighthouse::DefinitionError, "@node(resolver: #{reference.inspect}) names no class." unless klass
+
+    receiver = Lighthouse::GraphQL::ResolverDispatch.callable_receiver(klass, method || :call)
+    receiver.public_send(method || :call, id, context)
+  end
+
+  def self.model_for(type, name)
+    return Lighthouse::Support::ModelResolver.constantize(name) if name
+
+    Lighthouse::GraphQL::Directives::ModelDirective.model_for(type)
+  end
+end

data/lib/lighthouse/pagination.rb

@@ -110,6 +110,9 @@ module Lighthouse::GraphQL::Pagination
       @items = items
     end
 
+    # The records on the page, for @lazyLoad.
+    attr_reader :items
+
     def marshal_dump
       [info, @items]
     end

data/lib/lighthouse/rb_lighthouse.rb

@@ -29,6 +29,8 @@ require_relative 'namespaces'
   support/arguments
   support/batching
   support/soft_deletes
+  support/preload
+  support/environment
   where_conditions/operator_map
   contracts/directive
   contracts/field_resolver
@@ -38,6 +40,7 @@ require_relative 'namespaces'
   contracts/arg_builder
   sdl_loader
   generated_resolvers
+  default_resolve_dispatcher
   federation_directives
   field_resolver_stack
   events
@@ -60,12 +63,26 @@ require_relative 'namespaces'
   complexity_analyzer
   broadcasting
   subscription
+  type
+  type_resolution
+  resolve_info
+  global_id
+  enum_directive
+  upload
+  upload_store
+  multipart_request
+  node_registry
+  scalar_coercion
   pagination
   relation_batch
+  relation_counts
   nested_mutations
   directives/pagination_manipulator
   directives/where_conditions_directive
   directives/soft_deletes_directive
+  directives/node_directive
+  directives/model_directive
+  directives/visibility_directive
   directive_resolvers/aggregate_resolver
   directive_resolvers/field_resolver
   directive_resolvers/where_conditions_applier
@@ -83,6 +100,7 @@ require_relative 'namespaces'
   directive_resolvers/association_resolvers
   directive_resolvers/can_resolvers
   directive_resolvers/convention_resolver
+  directive_resolvers/type_method_resolver
   directive_resolvers/model_mutation_resolver
   directive_resolvers/soft_delete_resolvers
   directive_resolvers/cache_resolvers
@@ -91,15 +109,29 @@ require_relative 'namespaces'
   directive_resolvers/broadcast_resolver
   directive_resolvers/event_resolver
   directive_resolvers/convert_empty_strings_resolver
+  directive_resolvers/with_resolver
+  directive_resolvers/with_count_resolver
+  directive_resolvers/lazy_load_resolver
+  directive_resolvers/limit_resolver
+  directive_resolvers/namespaced_resolver
+  directive_resolvers/throttle_resolver
+  directive_resolvers/async_resolver
+  directive_resolvers/global_id_resolver
+  directive_resolvers/argument_binding
+  directive_resolvers/argument_transforms_resolver
   directives/arguments/base
   directives/arguments/filters
+  directives/arguments/more_filters
   directives/arguments/order_by
   directives/arguments/soft_deletes
+  directives/definitions
   directives/registry
   dataloader_sources/association_loader
   dataloader_sources/model_loader
   dataloader_sources/relation_page_loader
   dataloader_sources/relation_count_loader
+  dataloader_sources/relation_counts_loader
+  dataloader_sources/preload_loader
   ide_helper
 ].each do |rel|
   require_relative rel
@@ -109,6 +141,7 @@ end
 
 # The activejob gem is optional: the job that queues @broadcast loads on first use.
 Lighthouse::GraphQL.autoload(:BroadcastJob, File.expand_path('broadcast_job.rb', __dir__))
+Lighthouse::GraphQL.autoload(:AsyncMutationJob, File.expand_path('async_mutation_job.rb', __dir__))
 
 require_relative 'railtie' if defined?(Rails::Railtie)
 

data/lib/lighthouse/relation_counts.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# The counts @withCount loads, read off the record as Laravel's withCount
+# attributes are: `user.posts_count`. The record is extended with this module
+# (named, so it still marshals for @cache) and keeps them in an instance
+# variable; a real column of the same name wins.
+module Lighthouse::GraphQL::RelationCounts
+  def self.write(record, relation, count)
+    record.extend(self) unless record.is_a?(self)
+    counts = record.instance_variable_get(:@lighthouse_relation_counts) || {}
+    record.instance_variable_set(:@lighthouse_relation_counts, counts.merge("#{relation}_count" => count))
+  end
+
+  def respond_to_missing?(name, include_private = false)
+    lighthouse_relation_count?(name) || super
+  end
+
+  def method_missing(name, *args, &block)
+    return super unless args.empty? && lighthouse_relation_count?(name)
+
+    @lighthouse_relation_counts[name.to_s]
+  end
+
+  private
+
+  def lighthouse_relation_count?(name)
+    @lighthouse_relation_counts&.key?(name.to_s)
+  end
+end

data/lib/lighthouse/resolve_info.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# What PHP Lighthouse hands a resolver as its fourth argument, `$resolveInfo`:
+# the field being resolved, where, with what, what the client selects below it
+# (`lookahead`), and `enhance_builder`, which applies the field's own query
+# directives to a query the resolver builds.
+#
+#   type Query {
+#     posts(title: String @eq, orderBy: [PostOrderByClause!] @orderBy): [Post!]! @builder(class: "Published")
+#   }
+#
+#   class Resolvers::Posts < Resolvers::BaseResolver
+#     def resolve(**)
+#       resolve_info.enhance_builder(Post.where(author: context[:current_user]), scopes: [:recent])
+#     end
+#   end
+#
+# A Resolvers:: / Mutations:: class, a class @field names and a type class's
+# methods read it as `resolve_info`; a plain callable gets it as a fourth
+# argument when it takes one: `call(object, args, context, resolve_info)`.
+class Lighthouse::GraphQL::ResolveInfo
+  LOOKAHEAD = :lighthouse_lookahead
+
+  attr_reader :field, :parent_type, :object, :arguments, :context
+
+  # graphql-ruby's GraphQL::Execution::Lookahead for the field: what the client
+  # selects below it, to load only that (`lookahead.selects?(:author)`,
+  # `lookahead.selection(:comments).arguments`). nil outside a query.
+  attr_reader :lookahead
+
+  # A field resolved by a class asks graphql-ruby for its lookahead.
+  def self.request_lookahead(field_def)
+    field_def.extras([:lookahead]) unless field_def.extras.include?(:lookahead)
+  end
+
+  def initialize(field:, parent_type:, object:, arguments:, context:)
+    @field = field
+    @parent_type = parent_type
+    @object = object
+    @arguments = arguments
+    @context = context
+    @lookahead = context.respond_to?(:[]) ? context[LOOKAHEAD] : nil
+  end
+
+  def field_name = field.graphql_name
+
+  def return_type = field.type
+
+  # The path from the root to this field, as graphql-ruby tracks it: ["posts", 0, "author"].
+  def path
+    context.respond_to?(:[]) ? context[:current_path] : nil
+  end
+
+  # `relation` with the field's model `scopes`, its @builder classes, and the
+  # argument directives the client used (@eq, @where, @in, @like, @orderBy,
+  # @whereConditions, @trashed, ...), as @all / @paginate apply them.
+  def enhance_builder(relation, scopes: [])
+    resolver = Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver.new(field, parent_type, nil)
+    args = arguments.respond_to?(:to_h) ? arguments.to_h : {}
+    relation = Array(scopes).reduce(relation) { |acc, scope| acc.public_send(scope) }
+    relation = Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply(relation, field.ast_node, args, context, resolver)
+    resolver.apply_where_filters(relation, args, context)
+  end
+
+  # `resolve_info`, for the classes that resolve a field.
+  module Accessor
+    def resolve_info = @lighthouse_resolve_info
+  end
+
+  # Hand `info` to `resolver` (a GraphQL::Schema::Resolver or type class instance).
+  def self.for(field_def, parent_type, object, arguments, context)
+    new(field: field_def, parent_type: parent_type, object: object, arguments: arguments, context: context)
+  end
+
+  def self.attach(resolver, info)
+    resolver.extend(Accessor) unless resolver.respond_to?(:resolve_info)
+    resolver.instance_variable_set(:@lighthouse_resolve_info, info)
+    resolver
+  end
+end

data/lib/lighthouse/resolver_bases.rb

@@ -31,8 +31,13 @@ module Lighthouse::GraphQL::ResolverBases
 
   module_function
 
+  # graphql-ruby's base types that the type classes of the same kind
+  # (Types::PostType, Types::DateTimeType, ...) inherit from too.
+  TYPE_KINDS = %i[object union interface scalar].freeze
+
   # Take the three keys out of opts[:base_types] (the caller's Hash is not
-  # changed) and return { root kind => base class } for those given.
+  # changed) and return { root kind => base class } for those given, plus
+  # :types => { kind => base } for graphql-ruby's own, which stay in opts.
   def extract!(opts)
     base_types = opts[:base_types]
     return {} unless base_types.is_a?(Hash)
@@ -40,7 +45,9 @@ module Lighthouse::GraphQL::ResolverBases
     given = base_types.slice(*GRAPHQL_CLASSES.keys).compact
     opts[:base_types] = base_types.except(*GRAPHQL_CLASSES.keys)
     given.each { |key, klass| validate!(key, klass) }
-    KEYS.filter_map { |kind, key| [kind, given[key]] if given[key] }.to_h
+    bases = KEYS.filter_map { |kind, key| [kind, given[key]] if given[key] }.to_h
+    type_bases = base_types.slice(*TYPE_KINDS).compact
+    type_bases.empty? ? bases : bases.merge(types: type_bases)
   end
 
   def validate!(key, klass)