lighthouse-graphql 0.4.0 → 0.6.0

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
@@ -45,6 +48,7 @@ require_relative 'namespaces'
   events/execution_trace
   events/schema_build
   resolver_bases
+  root_types
   schema_generator
   schema_cache
   persisted_queries
@@ -60,12 +64,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 +101,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 +110,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 +142,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

@@ -18,6 +18,11 @@
 #   it is first used, so none misses what the base shares;
 # - for subscriptions, also resolves a Subscription field that has no class of
 #   its own, instead of Lighthouse::GraphQL::Subscription::Default.
+#
+# The code-first types graphql-ruby's install writes are bases too (RootTypes):
+# `query_type:` / `mutation_type:` / `subscription_type:` (Types::QueryType, ...)
+# are what the SDL's root types are built on, so their `field`s are the
+# schema's too, and `node:` (Types::NodeType) is the SDL's Node interface.
 module Lighthouse::GraphQL::ResolverBases
   # base_types key => the graphql-ruby class the base must inherit from.
   GRAPHQL_CLASSES = {
@@ -31,16 +36,32 @@ module Lighthouse::GraphQL::ResolverBases
 
   module_function
 
-  # 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.
+  # 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 Lighthouse's keys out of opts[:base_types] (the caller's Hash is not
+  # changed) and return { root kind => base class } for those given, plus
+  # :types => { kind => base } for graphql-ruby's own, which stay in opts, and
+  # :roots => { query_type: ..., node: ... } for the code-first types (RootTypes).
   def extract!(opts)
     base_types = opts[:base_types]
     return {} unless base_types.is_a?(Hash)
 
     given = base_types.slice(*GRAPHQL_CLASSES.keys).compact
-    opts[:base_types] = base_types.except(*GRAPHQL_CLASSES.keys)
+    opts[:base_types] = base_types.except(*GRAPHQL_CLASSES.keys, *Lighthouse::GraphQL::RootTypes::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
+    bases = bases.merge(types: type_bases) unless type_bases.empty?
+    with_roots(bases, base_types)
+  end
+
+  # `bases` with the code-first root types given, validated, under :roots.
+  def with_roots(bases, base_types)
+    roots = base_types.slice(*Lighthouse::GraphQL::RootTypes::KEYS).compact
+    roots.each { |key, type| Lighthouse::GraphQL::RootTypes.validate!(key, type) }
+    roots.empty? ? bases : bases.merge(roots: roots)
   end
 
   def validate!(key, klass)

data/lib/lighthouse/resolver_dispatch.rb

@@ -4,7 +4,12 @@
 # namespaces follow graphql-ruby's contract — GraphQL::Schema::Resolver and
 # GraphQL::Schema::Mutation: `resolve(**args)` with `object` and `context`,
 # plus `ready?` / `authorized?` — exactly as in a graphql-ruby schema.
-# @field also accepts a plain callable, `call(object, args, context)`.
+# @field also accepts a plain callable, `call(object, args, context)`, which
+# gets the ResolveInfo as a fourth argument when it takes one.
+#
+# `method:` is the method after `@` in `@field(resolver: "Class@method")`: it
+# replaces `resolve` (keeping `ready?` / `authorized?`) on a resolver class, and
+# `call` on a plain class, as a class method or else an instance method.
 module Lighthouse::GraphQL::ResolverDispatch
   module_function
 
@@ -12,15 +17,50 @@ module Lighthouse::GraphQL::ResolverDispatch
     klass.is_a?(Class) && klass < ::GraphQL::Schema::Resolver
   end
 
-  def call(klass, field_def, obj, args, ctx)
-    if graphql_resolver?(klass)
-      kwargs = Lighthouse::Support::Arguments.prepare(field_def, args, ctx)
-      klass.new(object: obj, context: ctx, field: field_def).resolve_with_support(**kwargs)
-    elsif klass.respond_to?(:call)
-      klass.call(obj, args, ctx)
-    else
-      instance = klass.new
-      instance.respond_to?(:call) ? instance.call(obj, args, ctx) : instance.resolve(obj, args, ctx)
-    end
+  # `info`: the ResolveInfo of the field being resolved, which carries its
+  # object, arguments and context.
+  def call(klass, info, method: nil)
+    return call_resolver(klass, info, method) if graphql_resolver?(klass)
+
+    receiver = callable_receiver(klass, method || :call)
+    callable = receiver.method(method || (receiver.respond_to?(:call) ? :call : :resolve))
+    args = [info.object, info.arguments, info.context]
+    takes_info?(receiver, callable) ? callable.call(*args, info) : callable.call(*args)
+  end
+
+  def call_resolver(klass, info, method)
+    kwargs = Lighthouse::Support::Arguments.prepare(info.field, info.arguments, info.context)
+    instance = Lighthouse::GraphQL::ResolveInfo.attach(klass.new(object: info.object, context: info.context, field: info.field), info)
+    instance.define_singleton_method(:resolve) { |**values| public_send(method, **values) } if method
+    single_input?(instance, kwargs) ? instance.resolve_with_support(**kwargs) : resolve_as_mutation(instance, kwargs)
+  end
+
+  # graphql-ruby's RelayClassicMutation (the base mutation its install writes)
+  # takes one `input:` argument. A field that declares its arguments one by one
+  # calls it as a plain GraphQL::Schema::Mutation, with them as keywords: past
+  # HasSingleInputArgument's unwrapping of `input:`, and its authorization of
+  # the arguments of `input:`.
+  def single_input?(instance, kwargs)
+    !instance.is_a?(::GraphQL::Schema::HasSingleInputArgument) || kwargs.key?(:input)
+  end
+
+  def resolve_as_mutation(instance, kwargs)
+    instance.define_singleton_method(:authorize_arguments, ::GraphQL::Schema::Resolver.instance_method(:authorize_arguments))
+    instance.singleton_class.send(:private, :authorize_arguments)
+    ::GraphQL::Schema::Mutation.instance_method(:resolve_with_support).bind_call(instance, **kwargs)
+  end
+
+  # The class itself when it answers `name` as a class method, else an instance.
+  def callable_receiver(klass, name)
+    klass.respond_to?(name) ? klass : klass.new
+  end
+
+  POSITIONAL = %i[req opt].freeze
+
+  # Does the callable take a fourth argument? A lambda's own parameters count,
+  # not Proc#call's (*args).
+  def takes_info?(receiver, callable)
+    params = receiver.is_a?(Proc) && callable.name == :call ? receiver.parameters : callable.parameters
+    params.any? { |type, _| type == :rest } || params.count { |type, _| POSITIONAL.include?(type) } >= 4
   end
 end

data/lib/lighthouse/root_types.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+# The code-first types graphql-ruby's install writes, which a schema builds on:
+#
+#   base_types: { query_type: Types::QueryType, mutation_type: Types::MutationType,
+#                 subscription_type: Types::SubscriptionType, node: Types::NodeType }
+#
+# - A root type given is what the SDL's root type of that kind is built on,
+#   instead of base_types[:object]: the SDL's `type Query` is a subclass of
+#   Types::QueryType, so the `field`s the class declares (graphql-ruby's
+#   `node` / `nodes`, what `graphql:mutation` adds to Types::MutationType)
+#   are the schema's too, beside the SDL's, and resolve as in graphql-ruby. An
+#   SDL field of the same name wins. With no such root type in the SDL, the
+#   class itself is the root, once it declares a field.
+# - `node:` is the SDL's Node interface: `interface Node`, which @node adds and
+#   `implements Node` names, is that module, so graphql-ruby's Relay
+#   (Query.node / nodes, the schema's id_from_object / object_from_id) and the
+#   SDL's @node types share one Node. The `node` field @node adds to Query then
+#   gives way to the root type class's own.
+#
+# graphql-ruby's builder knows one base per kind, so the hook into it is a
+# patch (graphql_ruby_patches.rb), which reads the bases of the build in
+# progress from here.
+module Lighthouse::GraphQL::RootTypes
+  KEYS = %i[query_type mutation_type subscription_type node].freeze
+
+  ROOTS = { query_type: :query, mutation_type: :mutation, subscription_type: :subscription }.freeze
+
+  # The resolver of the `node` field @node adds to Query.
+  NODE_RESOLVER = 'Lighthouse::GraphQL::NodeRegistry@resolve'
+
+  module_function
+
+  def validate!(key, type)
+    valid = key == :node ? Lighthouse::GraphQL::Type.kind_of(type) == :interface : type.is_a?(Class) && type < ::GraphQL::Schema::Object
+    return if valid
+
+    expected = key == :node ? 'a module including GraphQL::Schema::Interface' : 'a subclass of GraphQL::Schema::Object'
+    raise Lighthouse::DefinitionError, "base_types[:#{key}] must be #{expected}, not #{type.inspect}."
+  end
+
+  # The root type class the SDL's root type of `root_kind` (:queries,
+  # :mutations) is built on, when it is Lighthouse's (Lighthouse::GraphQL::Type):
+  # its methods resolve the root fields of their name.
+  def type_class(root_kind, roots)
+    klass = roots&.[]({ queries: :query_type, mutations: :mutation_type }[root_kind])
+    klass if klass&.include?(Lighthouse::GraphQL::Type)
+  end
+
+  # Run the block (the build of `document`) with `roots` as the bases of the
+  # types they name.
+  def with(document, roots)
+    previous = Thread.current[:lighthouse_root_types]
+    Thread.current[:lighthouse_root_types] = by_type_name(document, roots || {})
+    yield
+  ensure
+    Thread.current[:lighthouse_root_types] = previous
+  end
+
+  # The class an SDL type of `name` is built on, or nil.
+  def base_for(name)
+    Thread.current[:lighthouse_root_types]&.[](name)
+  end
+
+  # `definition` without the fields `base` declares itself that @node added.
+  def definition_on(definition, base)
+    names = field_names(base)
+    fields = definition.fields.reject { |field| names.include?(field.name) && added_by_node?(field) }
+    fields.size == definition.fields.size ? definition : definition.merge(fields: fields)
+  end
+
+  # The names of the fields a class and its ancestors declare. Not `fields`,
+  # which warns about a type with none (graphql-ruby's install leaves
+  # Types::MutationType empty once its example field goes).
+  def field_names(type)
+    type.ancestors.select { |ancestor| ancestor.respond_to?(:own_fields) }.flat_map { |ancestor| ancestor.own_fields.keys }.uniq
+  end
+
+  # The schema the block builds from `document`, with `roots` as the bases of
+  # the types they name; then the root type classes the SDL has no type for,
+  # and the subscriptions backend an app schema class `use`s (graphql_ruby_patches.rb).
+  def build(document, roots, &block)
+    schema = with(document, roots, &block)
+    apply_missing(schema, roots)
+    schema.extend(Lighthouse::GraphQL::InheritedSubscriptionRoot) if schema.respond_to?(:add_subscription_extension_if_necessary, true)
+    schema
+  end
+
+  # A root type class the SDL has no type for is the root itself, once it
+  # declares a field (graphql-ruby's install writes them with an example one).
+  def apply_missing(schema, roots)
+    ROOTS.each do |key, root|
+      type = roots&.[](key)
+      next if type.nil? || schema.public_send(root) || field_names(type).empty?
+
+      schema.public_send(root, type)
+    end
+  end
+
+  def by_type_name(document, roots)
+    names = root_names(document)
+    mapped = ROOTS.each_with_object({}) { |(key, root), out| out[names[root]] = roots[key] if roots[key] }
+    roots[:node] ? mapped.merge('Node' => roots[:node]) : mapped
+  end
+
+  # { query: 'Query', ... }, as the document's `schema { }` names them.
+  def root_names(document)
+    schema = document.definitions.find { |definition| definition.is_a?(::GraphQL::Language::Nodes::SchemaDefinition) }
+    { query: schema&.query || 'Query', mutation: schema&.mutation || 'Mutation', subscription: schema&.subscription || 'Subscription' }
+  end
+
+  def added_by_node?(field)
+    field.directives.any? do |directive|
+      directive.name == 'field' && Lighthouse::Support::DirectiveArgs.literal(directive, 'resolver') == NODE_RESOLVER
+    end
+  end
+end

data/lib/lighthouse/scalar_coercion.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# How the values of an SDL scalar (`scalar DateTime`) are read from a query and
+# written to a response, as a graphql-ruby scalar class does it with
+# `coerce_input(value, context)` and `coerce_result(value, context)`. The class
+# is, in order:
+#
+# 1. the one `@scalar(class: "Name")` on the scalar names, looked up in
+#    Config.namespaces[:types] (nested names too) and then as written. PHP
+#    Lighthouse's directive.
+# 2. Its type class, Types::<Name>Type including Lighthouse::GraphQL::Type: a
+#    GraphQL::Schema::Scalar, as graphql-ruby's `rails g graphql:scalar` writes it.
+# 3. Lighthouse's own, for `scalar Upload` (Lighthouse::GraphQL::Upload).
+#
+# A scalar with none passes its values through unchanged. A class raising
+# GraphQL::CoercionError from coerce_input (or returning nil for a value) makes
+# the argument invalid, with that message, as in graphql-ruby.
+module Lighthouse::GraphQL::ScalarCoercion
+  DEFINITION = <<~GRAPHQL.chomp
+    """
+    The class that reads and writes this scalar's values: coerce_input(value, context) and
+    coerce_result(value, context), as a GraphQL::Schema::Scalar.
+    """
+    directive @scalar(class: String!) on SCALAR
+  GRAPHQL
+
+  module_function
+
+  # Give every SDL scalar that has a class its coercion. The class is looked up
+  # again on each value, so code reloading keeps working; `bases` is the
+  # schema's base_types[:scalar], which a type class must inherit from.
+  def apply(schema, base = nil)
+    schema.types.each_value do |type|
+      next unless type.kind.scalar? && type.ast_node
+
+      klass = class_for(type, base)
+      install(type, klass) if klass
+    end
+  end
+
+  # Scalars Lighthouse brings a class for, when nothing else names one.
+  BUILT_IN = { 'Upload' => 'Lighthouse::GraphQL::Upload' }.freeze
+
+  def class_for(scalar_type, base = nil)
+    directive_class(scalar_type) || type_class(scalar_type, base) || BUILT_IN[scalar_type.graphql_name]&.constantize
+  end
+
+  def directive_class(scalar_type)
+    directive = (scalar_type.ast_node.directives || []).find { |d| d.name == 'scalar' }
+    name = directive && Lighthouse::Support::DirectiveArgs.literal(directive, 'class')
+    return unless name
+
+    klass = Lighthouse::Support::ModelResolver.constantize(name, namespaces: Lighthouse::Config.namespaces[:types], nested: true)
+    return klass if klass.respond_to?(:coerce_input) && klass.respond_to?(:coerce_result)
+
+    raise Lighthouse::DefinitionError,
+          "@scalar(class: #{name.inspect}) on #{scalar_type.graphql_name} names no class with coerce_input(value, context) " \
+          'and coerce_result(value, context).'
+  end
+
+  def type_class(scalar_type, base)
+    klass = Lighthouse::GraphQL::Type.class_for(scalar_type.graphql_name, :scalar)
+    Lighthouse::GraphQL::ResolverBases.check!(klass, base, "the #{scalar_type.graphql_name} scalar") if klass
+    klass
+  end
+
+  def install(scalar_type, klass)
+    current = -> { klass.name ? klass.name.constantize : klass }
+    scalar_type.define_singleton_method(:coerce_input) { |value, ctx| current.call.coerce_input(value, ctx) }
+    scalar_type.define_singleton_method(:coerce_result) { |value, ctx| current.call.coerce_result(value, ctx) }
+  end
+end

data/lib/lighthouse/schema_cache.rb

@@ -72,7 +72,8 @@ module Lighthouse::GraphQL::SchemaCache
       registry.directive_definitions.sort,
       registry.type_definitions.sort,
       manipulators,
-      Lighthouse::Config.pagination_default_count
+      Lighthouse::Config.pagination_default_count,
+      Lighthouse::Support::Environment.current # @hide / @show
     ].inspect
   end
 

data/lib/lighthouse/schema_generator.rb

@@ -15,8 +15,8 @@ module Lighthouse::GraphQL::SchemaGenerator
       obj.respond_to?(field_name) ? obj.public_send(field_name) : nil
     end
 
-    def resolve_type(_abstract_type, _obj, _ctx)
-      nil
+    def resolve_type(abstract_type, obj, ctx)
+      Lighthouse::GraphQL::TypeResolution.resolve(ctx.respond_to?(:schema) && ctx.schema ? ctx.schema : schema, abstract_type, obj, ctx)
     end
 
     def coerce_input(_type, value, _ctx)
@@ -47,7 +47,7 @@ module Lighthouse::GraphQL::SchemaGenerator
     impl = default_implementation
     # base_types' resolver / mutation / subscription are Lighthouse's, not graphql-ruby's.
     bases = Lighthouse::GraphQL::ResolverBases.extract!(opts)
-    schema = from_document(document, impl, opts)
+    schema = Lighthouse::GraphQL::RootTypes.build(document, bases[:roots]) { from_document(document, impl, opts) }
 
     delegate_to_federation_sdl(schema)
     Lighthouse::GraphQL::GeneratedResolvers.install_dispatcher(schema)
@@ -139,7 +139,10 @@ module Lighthouse::GraphQL::SchemaGenerator
       # Apply object-level federation directives to generated types so the
       # Apollo Federation helper can detect entities and add _entities.
       Lighthouse::GraphQL::FederationDirectives.apply(type)
-      type.fields.each_value { |field_def| process_field(type, field_def, root_kinds[type.graphql_name], bases) }
+      root_kind = root_kinds[type.graphql_name]
+      type_class = Lighthouse::GraphQL::DirectiveResolvers::TypeMethodResolver.type_class(type.graphql_name, bases, root_kind)
+      # A field a code-first base declares (RootTypes) resolves as graphql-ruby resolves it.
+      type.fields.each_value { |field_def| process_field(type, field_def, root_kind, bases, type_class) if field_def.owner == type }
     end
 
     # @complexity, and paginated fields, give graphql-ruby's complexity analysis their cost.
@@ -151,6 +154,9 @@ module Lighthouse::GraphQL::SchemaGenerator
     # Every @broadcast must name a field of the Subscription type.
     Lighthouse::GraphQL::Broadcasting.validate!(schema)
 
+    # Unions, interfaces and scalars get the classes that resolve and coerce them.
+    Lighthouse::GraphQL::Type.apply(schema, bases.fetch(:types, {}))
+
     # return schema for convenience
     schema
   end
@@ -163,10 +169,11 @@ module Lighthouse::GraphQL::SchemaGenerator
 
   # A field's generated resolvers, then the runtime hooks that make
   # graphql-ruby reach them.
-  def process_field(type, field_def, root_kind, bases = {})
+  def process_field(type, field_def, root_kind, bases = {}, type_class = nil)
     return unless field_def.ast_node
 
-    apply_field_resolvers(type, field_def, field_def.ast_node.directives || [], root_kind, bases)
+    # Installed in resolution order (see FieldResolverStack).
+    Lighthouse::GraphQL::FieldResolverStack.apply(type, field_def, root_kind, bases: bases, type_class: type_class)
     Lighthouse::GraphQL::GeneratedResolvers.route_runtime_resolver(type, field_def)
     ensure_connection_extension(field_def)
   end
@@ -187,11 +194,6 @@ module Lighthouse::GraphQL::SchemaGenerator
     # ignore failures during post-processing
   end
 
-  # A field's resolvers, installed in resolution order (see FieldResolverStack).
-  def apply_field_resolvers(type, field_def, directives, root_kind, bases = {})
-    Lighthouse::GraphQL::FieldResolverStack.apply(type, field_def, directives, root_kind, bases: bases)
-  end
-
   # Scan SDL string for list-typed fields that carry relationship directives
   # and produce Connection/Edge types where missing. This is a lightweight
   # transformation that mirrors Lighthouse behavior: clients can declare

data/lib/lighthouse/schema_implementation.rb

@@ -27,14 +27,10 @@ class SchemaImplementation
     read_attribute(obj, field_name)
   end
 
-  def resolve_type(abstract_type, _obj, _ctx)
-    # Try to resolve to a Ruby type class under Types::<Name>Type
-    type_name = abstract_type.respond_to?(:name) ? abstract_type.name : abstract_type.to_s
-    begin
-      Object.const_get("Types::#{type_name}Type")
-    rescue StandardError
-      nil
-    end
+  # The object type of a union's or interface's value (see TypeResolution).
+  def resolve_type(abstract_type, obj, ctx)
+    schema = ctx.respond_to?(:schema) && ctx.schema ? ctx.schema : @schema
+    Lighthouse::GraphQL::TypeResolution.resolve(schema, abstract_type, obj, ctx)
   end
 
   def coerce_input(_type, value, _ctx)

data/lib/lighthouse/support/environment.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# The application's environment, for @hide and @show: Rails.env, else
+# RAILS_ENV or RACK_ENV, else "development".
+module Lighthouse::Support::Environment
+  module_function
+
+  def current
+    return Rails.env.to_s if defined?(Rails) && Rails.respond_to?(:env)
+
+    ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+  end
+end

data/lib/lighthouse/support/model_resolver.rb

@@ -26,14 +26,16 @@ module Lighthouse::Support::ModelResolver
   # `namespaces:` overrides the configured resolver_namespaces, e.g. with
   # Config.namespaces[:builders] to look a builder class up.
   # `fallback: false` skips the bare name, so `Resolvers::User` is never
-  # mistaken for the `User` model.
-  def constantize(name, namespaces: self.namespaces, fallback: true)
+  # mistaken for the `User` model. `nested: true` tries the namespaces before a
+  # name that already contains `::` too, so `Feeds::Home` is found as
+  # `Resolvers::Feeds::Home`; otherwise such a name is used as-is.
+  def constantize(name, namespaces: self.namespaces, fallback: true, nested: false)
     return nil unless name
 
     raw = name.to_s.strip
     return nil if raw.empty?
 
-    candidates_for(raw, namespaces, fallback: fallback).each do |candidate|
+    candidates_for(raw, namespaces, fallback: fallback, nested: nested).each do |candidate|
       klass = try_constantize(candidate)
       return klass if klass
     end
@@ -41,8 +43,8 @@ module Lighthouse::Support::ModelResolver
     nil
   end
 
-  def candidates_for(raw, namespaces = self.namespaces, fallback: true)
-    if raw.include?('::')
+  def candidates_for(raw, namespaces = self.namespaces, fallback: true, nested: false)
+    if raw.include?('::') && !nested
       [raw]
     else
       Array(namespaces).map { |ns| "#{ns}::#{raw}" } + (fallback ? [raw] : [])