lighthouse-graphql 0.5.0 → 0.7.0

data/lib/lighthouse/ide_helper.rb

@@ -13,7 +13,13 @@ require 'fileutils'
 #   ...), which exist in the executable schema but in no .graphql file.
 #
 # Point your IDE's graphql-config at both files next to your own SDL. Run it
-# with `bin/rails lighthouse:ide_helper`.
+# with `bin/rails lighthouse:ide_helper`; in development, an app with a
+# graphql.config.yml also gets them rewritten on boot and on every reload
+# (Config.ide_helper).
+#
+# The IDE reads the three together as one schema, so no type may be in two of
+# them: graphql-js (the VS Code and JetBrains plugins) rejects a type defined
+# twice, even where graphql-ruby keeps the last definition.
 module Lighthouse::IdeHelper
   DIRECTIVES_FILE = 'schema-directives.graphql'
   PROGRAMMATIC_TYPES_FILE = 'programmatic-types.graphql'
@@ -27,23 +33,66 @@ module Lighthouse::IdeHelper
     ::GraphQL::Language::Nodes::ScalarTypeDefinition
   ].freeze
 
-  PLACEHOLDER_SCALAR = %("Placeholder for an argument type Lighthouse generates, e.g. with @whereConditions."\nscalar _)
+  PLACEHOLDER_SCALAR = %("Placeholder for an argument type Lighthouse generates, e.g. with @whereConditions or @orderBy."\nscalar _)
 
   module_function
 
-  # Writes both files into `output_dir` and returns their paths.
-  def write(output_dir:, sdl_folder: Lighthouse::Config.sdl_folder, registry: Lighthouse::DirectiveRegistry.default)
-    sdl = sdl_folder && Dir.exist?(sdl_folder.to_s) ? Lighthouse::GraphQL::SDLLoader.load_from_folder(sdl_folder.to_s) : ''
+  # Writes both files into `output_dir` and returns their paths. A file whose
+  # content has not changed is left alone, so the IDE does not reload for nothing.
+  #
+  # A schema that does not build (a type defined twice, half-written, ...)
+  # still gets its directives, and keeps the programmatic types it had, or
+  # gets the `_` placeholder alone: the IDE never loses a type it was given.
+  def write(output_dir:, schema_path: Lighthouse::Config.schema_path, registry: Lighthouse::DirectiveRegistry.default)
+    sdl = ide_sdl(schema_path)
+    directives = directives_sdl(sdl, registry: registry)
 
     FileUtils.mkdir_p(output_dir.to_s)
-    {
-      DIRECTIVES_FILE => directives_sdl(sdl, registry: registry),
-      PROGRAMMATIC_TYPES_FILE => programmatic_types_sdl(sdl, registry: registry)
-    }.map do |name, content|
-      path = File.join(output_dir.to_s, name)
-      File.write(path, content)
-      path
+    directives_path = write_file(output_dir, DIRECTIVES_FILE, directives)
+    types_path = File.join(output_dir.to_s, PROGRAMMATIC_TYPES_FILE)
+    begin
+      write_file(output_dir, PROGRAMMATIC_TYPES_FILE, programmatic_types_sdl(sdl, registry: registry, directives: directives))
+    rescue StandardError => e
+      warn("Lighthouse: #{PROGRAMMATIC_TYPES_FILE} kept as it was, the schema does not build: #{e.message}")
+      write_file(output_dir, PROGRAMMATIC_TYPES_FILE, placeholder_only(sdl)) unless File.exist?(types_path)
     end
+    [directives_path, types_path]
+  end
+
+  # The schema as the IDE reads it: the entrypoint and its imports, or, when
+  # they do not load, every .graphql file under the entrypoint's folder.
+  def ide_sdl(schema_path)
+    return '' unless schema_path
+
+    return Lighthouse::GraphQL::SchemaFactory.load_sdl(schema_path) if File.file?(schema_path.to_s)
+
+    raise Lighthouse::DefinitionError, "no schema at #{schema_path}"
+  rescue Lighthouse::DefinitionError
+    Dir[File.join(File.dirname(schema_path.to_s), '**', '*.graphql')].map { |file| File.read(file) }.join("\n")
+  end
+
+  def write_file(output_dir, name, content)
+    path = File.join(output_dir.to_s, name)
+    File.write(path, content) unless File.exist?(path) && File.read(path) == content
+    path
+  end
+
+  def placeholder_only(sdl)
+    declared = sdl.to_s.match?(/^\s*scalar\s+_\b/) ? Set['_'] : Set.new
+    render('The schema does not build: only the `_` placeholder is declared until it does.',
+           undeclared_placeholder?(sdl, declared) ? [PLACEHOLDER_SCALAR] : [])
+  end
+
+  # Config.ide_helper's refresh: the files in the Rails app's root, when the
+  # schema loads. A schema that does not is the next request's error to raise;
+  # here it only warns.
+  def refresh(output_dir: ::Rails.root)
+    return [] unless Lighthouse::Config.ide_helper
+
+    write(output_dir: output_dir)
+  rescue StandardError => e
+    warn("Lighthouse: the IDE helper files were not refreshed: #{e.message}")
+    []
   end
 
   def directives_sdl(sdl = '', registry: Lighthouse::DirectiveRegistry.default)
@@ -56,13 +105,12 @@ module Lighthouse::IdeHelper
     )
   end
 
-  def programmatic_types_sdl(sdl, registry: Lighthouse::DirectiveRegistry.default)
-    original = type_names(sdl)
-    generated = parse(registry.manipulate_sdl(sdl)).definitions.select do |definition|
-      type_definition?(definition) && original.exclude?(definition.name)
-    end
-    generated_sdl = generated.sort_by(&:name).map(&:to_query_string)
-    generated_sdl.unshift(PLACEHOLDER_SCALAR) if undeclared_placeholder?(sdl, original, generated)
+  # `directives`: the schema-directives.graphql written next to it, whose types
+  # (`CanAction`, `Mixed`, ...) some manipulators inject too and are left out here.
+  def programmatic_types_sdl(sdl, registry: Lighthouse::DirectiveRegistry.default, directives: directives_sdl(sdl, registry: registry))
+    declared = type_names(sdl) | type_names(directives)
+    generated_sdl = generated_types(sdl, declared, registry).sort_by(&:name).map(&:to_query_string)
+    generated_sdl.unshift(PLACEHOLDER_SCALAR) if undeclared_placeholder?(sdl, declared)
 
     render(
       'Types the manipulation phase generates (Connection/Paginator types, whereConditions inputs, ...).',
@@ -70,10 +118,19 @@ module Lighthouse::IdeHelper
     )
   end
 
-  # The manipulation phase replaces the `_` placeholder (`where: _ @whereConditions`),
-  # but the IDE reads the SDL as written, so it needs the placeholder declared.
-  def undeclared_placeholder?(sdl, original, generated)
-    sdl.to_s.match?(/:\s*\[?\s*_\b/) && original.exclude?('_') && generated.none? { |d| d.name == '_' }
+  # The types of the manipulated schema that neither the SDL nor the directives file defines.
+  def generated_types(sdl, declared, registry)
+    manipulated = Lighthouse::GraphQL::ASTBuilder.build(Lighthouse::GraphQL::SchemaGenerator.inject_directive_definitions(sdl), registry: registry)
+    parse(manipulated).definitions.select do |definition|
+      type_definition?(definition) && declared.exclude?(definition.name) && definition.name != '_'
+    end
+  end
+
+  # The manipulation phase replaces the `_` placeholder (`where: _ @whereConditions`,
+  # `orderBy: _ @orderBy`), but the IDE reads the SDL as written, so it needs
+  # the placeholder declared.
+  def undeclared_placeholder?(sdl, declared)
+    sdl.to_s.match?(/:\s*\[?\s*_\b/) && declared.exclude?('_')
   end
 
   def type_names(sdl)

data/lib/lighthouse/namespaces.rb

@@ -8,6 +8,7 @@ module Lighthouse
   module Contracts; end
   module Events; end
   module Generators; end
+  module OrderBy; end
   module Support; end
   module WhereConditions; end
 

data/lib/lighthouse/order_by/types.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+# The types @orderBy generates for an argument written with the `_`
+# placeholder, as PHP Lighthouse's OrderByDirective and OrderByServiceProvider
+# define them. For Query.posts(orderBy:), the prefix is QueryPostsOrderBy:
+#
+#   no columns:/columnsEnum:/relations:  [OrderByClause!]           column: String!, order: SortOrder!
+#   columns: / columnsEnum:              [<Prefix>OrderByClause!]   column: <Prefix>Column! (or the columnsEnum)
+#   relations:                           [<Prefix>RelationOrderByClause!]
+#     column: <Prefix>Column (or String), order: SortOrder!, and per relation
+#     <relation>: <Prefix><Relation> { aggregate: COUNT } or, with the relation's
+#     own columns:, { aggregate: AVG|MIN|MAX|SUM|COUNT, column: <Prefix><Relation>Column }
+class Lighthouse::OrderBy::Types
+  GeneratedTypes = Lighthouse::GraphQL::Directives::GeneratedTypes
+
+  DEFAULT_CLAUSE = 'OrderByClause'
+  SORT_ORDER = 'SortOrder'
+  AGGREGATE = 'OrderByRelationAggregateFunction'
+  AGGREGATE_WITH_COLUMN = 'OrderByRelationWithColumnAggregateFunction'
+
+  SDL = {
+    SORT_ORDER => <<~GRAPHQL,
+      "Directions for ordering a list of records."
+      enum SortOrder {
+        "Sort records in ascending order."
+        ASC
+
+        "Sort records in descending order."
+        DESC
+      }
+    GRAPHQL
+    AGGREGATE => <<~GRAPHQL,
+      "Aggregate functions when ordering by a relation without specifying a column."
+      enum OrderByRelationAggregateFunction {
+        "Amount of items."
+        COUNT @enum(value: "count")
+      }
+    GRAPHQL
+    AGGREGATE_WITH_COLUMN => <<~GRAPHQL
+      "Aggregate functions when ordering by a relation that may specify a column."
+      enum OrderByRelationWithColumnAggregateFunction {
+        "Average."
+        AVG @enum(value: "avg")
+
+        "Minimum."
+        MIN @enum(value: "min")
+
+        "Maximum."
+        MAX @enum(value: "max")
+
+        "Sum."
+        SUM @enum(value: "sum")
+
+        "Amount of items."
+        COUNT @enum(value: "count")
+      }
+    GRAPHQL
+  }.freeze
+
+  def initialize(document_ast, directive, arg, field, type)
+    @document_ast = document_ast
+    @directive = directive
+    @relations = Array(GeneratedTypes.directive_value(directive, 'relations')).map { |relation| relation.transform_keys(&:to_s) }
+    @arg = arg
+    @path = "#{type.name}.#{field.name}.#{arg.name}"
+    @prefix = GeneratedTypes.qualified_arg_type(arg, field, type)
+    @columns_enum = -> { GeneratedTypes.columns_enum(document_ast, directive, arg, field, type) }
+  end
+
+  # The argument, typed with the clauses generated for it.
+  def argument
+    @document_ast.define_type(SORT_ORDER, SDL[SORT_ORDER])
+    arg = GeneratedTypes.describe(@arg, "Order by clause for #{@path}.")
+    allowed = GeneratedTypes.allowed_columns?(@directive)
+    column_type = allowed ? @columns_enum.call : 'String'
+
+    clause =
+      if @relations.any? then relation_clause(column_type)
+      elsif allowed then column_clause("#{@prefix}OrderByClause", column_type, "Order by clause for #{@path}.")
+      else column_clause(DEFAULT_CLAUSE, 'String', 'Allows ordering a list of records.')
+      end
+    GeneratedTypes.replace_placeholder(arg, "[#{clause}!]")
+  end
+
+  private
+
+  def column_clause(name, column_type, description)
+    define(name, description, ["column: #{column_type}!", 'The column that is used for ordering.'], order_field)
+  end
+
+  # A column, or one relation's aggregate.
+  def relation_clause(column_type)
+    aggregates = @relations.map { |relation| ["#{relation['relation']}: #{aggregate_input(relation)}", 'Aggregate specification.'] }
+    define("#{@prefix}RelationOrderByClause", "Order by clause for #{@path}.",
+           ["column: #{column_type}", 'The column that is used for ordering.'], order_field, *aggregates)
+  end
+
+  # COUNT, or, with the relation's `columns:` / `columnsEnum:`, an aggregate of one of its columns.
+  def aggregate_input(relation)
+    name = "#{@prefix}#{GeneratedTypes.studly(relation['relation'])}"
+    columns_enum = relation_columns_enum(relation, name)
+    aggregate = columns_enum ? AGGREGATE_WITH_COLUMN : AGGREGATE
+    @document_ast.define_type(aggregate, SDL[aggregate])
+
+    fields = if columns_enum
+               [["aggregate: #{aggregate}!", 'The aggregate function to apply to the column.'],
+                ["column: #{columns_enum}", 'Name of the column to use.']]
+             else
+               [["aggregate: #{aggregate}!", 'Always COUNT.']]
+             end
+    define(name, "Aggregate specification for #{@path}.#{relation['relation']}.", *fields)
+  end
+
+  def relation_columns_enum(relation, name)
+    if relation['columns'] && relation['columnsEnum']
+      raise Lighthouse::DefinitionError,
+            "The relation #{relation['relation']} of @orderBy on #{@path} can only have one of the following arguments: `columns`, `columnsEnum`."
+    end
+    return relation['columnsEnum'] if relation['columnsEnum']
+    return nil unless relation['columns']
+
+    GeneratedTypes.define_columns_enum(@document_ast, "#{name}Column", relation['columns'], "#{@path}.#{relation['relation']}")
+    "#{name}Column"
+  end
+
+  def order_field
+    ["order: #{SORT_ORDER}!", 'The direction that is used for ordering.']
+  end
+
+  # Defines the input `name` with `fields`, each [SDL, description]; returns its name.
+  def define(name, description, *fields)
+    @document_ast.define_type(name) do
+      %("#{description}"\ninput #{name} {\n#{fields.map { |sdl, doc| %(  "#{doc}"\n  #{sdl}) }.join("\n\n")}\n}\n)
+    end
+    name
+  end
+end

data/lib/lighthouse/railtie.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 # Hooks Lighthouse into a Rails host: exposes the `lighthouse:*` rake tasks,
-# and — with `config.watch_sdl` — reloads the app when a .graphql file changes.
+# with `config.watch_sdl` reloads the app when a .graphql file changes, and
+# with `config.ide_helper` (on in development when the app has a
+# graphql.config.yml) rewrites the IDE helper files on boot and every reload.
 # Generators (`rails g lighthouse:install`) are found through lib/generators.
 class Lighthouse::Railtie < Rails::Railtie
   rake_tasks do
@@ -14,10 +16,15 @@ class Lighthouse::Railtie < Rails::Railtie
     Lighthouse::Railtie.watch_sdl(app.config)
   end
 
+  initializer 'lighthouse.ide_helper', after: :load_config_initializers do |app|
+    app.reloader.to_prepare { Lighthouse::IdeHelper.refresh(output_dir: app.root) }
+  end
+
   # Rails' reloader then treats a .graphql edit like a Ruby one: the app's
   # constants — the schema among them — are reloaded on the next request.
+  # Every .graphql under the entrypoint's folder is watched, imported or not.
   def self.watch_sdl(config)
-    folder = Lighthouse::Config.sdl_folder
+    folder = Lighthouse::Config.schema_directory
     return false unless Lighthouse::Config.watch_sdl && folder
 
     config.watchable_dirs[folder.to_s] = %w[graphql graphqls]

data/lib/lighthouse/rb_lighthouse.rb

@@ -38,7 +38,9 @@ require_relative 'namespaces'
   contracts/field_manipulator
   contracts/arg_manipulator
   contracts/arg_builder
-  sdl_loader
+  contracts/field_builder
+  schema_stitcher
+  document_ast
   generated_resolvers
   default_resolve_dispatcher
   federation_directives
@@ -48,6 +50,8 @@ require_relative 'namespaces'
   events/execution_trace
   events/schema_build
   resolver_bases
+  root_types
+  ast_builder
   schema_generator
   schema_cache
   persisted_queries
@@ -78,14 +82,18 @@ require_relative 'namespaces'
   relation_counts
   nested_mutations
   directives/pagination_manipulator
-  directives/where_conditions_directive
+  directives/generated_types
+  order_by/types
+  where_conditions/json_column
+  where_conditions/columns
+  where_conditions/types
+  where_conditions/handler
   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
   directive_resolvers/all_resolver
   directive_resolvers/find_resolver
   directive_resolvers/paginate_resolver
@@ -123,6 +131,9 @@ require_relative 'namespaces'
   directives/arguments/filters
   directives/arguments/more_filters
   directives/arguments/order_by
+  directives/arguments/where_conditions_base
+  directives/arguments/where_conditions
+  directives/arguments/where_has_conditions
   directives/arguments/soft_deletes
   directives/definitions
   directives/registry
@@ -147,12 +158,12 @@ require_relative 'railtie' if defined?(Rails::Railtie)
 
 module Lighthouse::GraphQL::RbLightHouse
   class << self
-    def get_schema(sdl_folder: nil, options: {})
+    def get_schema(schema_path: nil, options: {})
       base_types = options.delete(:base_types) || {}
       schema_class = options.delete(:base_schema)
 
       Lighthouse::GraphQL::SchemaFactory.build_base_schema(
-        sdl_folder: sdl_folder,
+        schema_path: schema_path,
         base_types: base_types,
         schema_options: options.merge(schema_class: schema_class)
       )

data/lib/lighthouse/resolve_info.rb

@@ -6,7 +6,7 @@
 # directives to a query the resolver builds.
 #
 #   type Query {
-#     posts(title: String @eq, orderBy: [PostOrderByClause!] @orderBy): [Post!]! @builder(class: "Published")
+#     posts(title: String @eq, orderBy: _ @orderBy(columns: ["title"])): [Post!]! @builder(class: "Published")
 #   }
 #
 #   class Resolvers::Posts < Resolvers::BaseResolver
@@ -51,14 +51,14 @@ class Lighthouse::GraphQL::ResolveInfo
     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.
+  # `relation` with the field's model `scopes`, the argument directives the
+  # client used (@eq, @where, @in, @like, @orderBy, @whereConditions, @trashed,
+  # ...), then the field's @builder, @whereAuth and @orderBy(column:), as
+  # @all / @paginate apply them and as PHP Lighthouse's enhanceBuilder does.
   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
 

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 = {
@@ -35,19 +40,28 @@ module Lighthouse::GraphQL::ResolverBases
   # (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
+  # 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.
+  # :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) }
     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)
+    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

@@ -32,7 +32,22 @@ module Lighthouse::GraphQL::ResolverDispatch
     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
-    instance.resolve_with_support(**kwargs)
+    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.

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

@@ -68,6 +68,10 @@ module Lighthouse::GraphQL::SchemaCache
   def fingerprint
     registry = Lighthouse::DirectiveRegistry.default
     manipulators = registry.sdl_manipulators.map { |manipulator| [manipulator.to_s, source_digest(manipulator)] }
+    phase = { Lighthouse::GraphQL::ASTBuilder => :build, Lighthouse::GraphQL::Directives::GeneratedTypes => :columns_enum,
+              Lighthouse::WhereConditions::Types => :define }
+    phase.merge!(registry.arg_manipulator_classes.index_with(:manipulate_arg_definition))
+    manipulators += phase.map { |manipulator, method_name| [manipulator.to_s, source_digest(manipulator, method_name)] }
     [
       registry.directive_definitions.sort,
       registry.type_definitions.sort,
@@ -77,10 +81,10 @@ module Lighthouse::GraphQL::SchemaCache
     ].inspect
   end
 
-  # Build the schema document now (from Config.sdl_folder, unless given)
+  # Build the schema document now (from Config.schema_path, unless given)
   # and return the cache file's path.
   def warm!(sdl = nil)
-    sdl ||= Lighthouse::GraphQL::SDLLoader.load_from_folder(Lighthouse::Config.sdl_folder.to_s)
+    sdl ||= Lighthouse::GraphQL::SchemaFactory.load_sdl
     Lighthouse::GraphQL::SchemaGenerator.build_document(sdl, force: true)
     File.join(directory.to_s, "#{PREFIX}#{key(sdl)}.bin")
   end
@@ -119,8 +123,8 @@ module Lighthouse::GraphQL::SchemaCache
     Lighthouse::Config.handle_error(e)
   end
 
-  def source_digest(manipulator)
-    file, = manipulator.method(:manipulate).source_location
+  def source_digest(manipulator, method_name = :manipulate)
+    file, = (manipulator.respond_to?(method_name) ? manipulator.method(method_name) : manipulator.instance_method(method_name)).source_location
     file && File.exist?(file) ? Digest::SHA256.file(file).hexdigest : nil
   rescue NameError
     nil

data/lib/lighthouse/schema_factory.rb

@@ -7,13 +7,13 @@
 module Lighthouse::GraphQL::SchemaFactory
   module_function
 
-  def build_base_schema(sdl_folder: nil, sdl: nil, base_types: {}, schema_options: {}, **extra_options)
+  def build_base_schema(schema_path: nil, sdl: nil, base_types: {}, schema_options: {}, **extra_options)
     # Absorb any extra keyword options (e.g. `federation: true`) into the
     # schema options bag so callers can pass schema-level flags directly
     # without the factory needing to enumerate every one.
     schema_options = extra_options.merge(schema_options)
 
-    sdl_string = sdl || load_sdl(sdl_folder)
+    sdl_string = sdl || load_sdl(schema_path)
     schema_class = schema_options.delete(:schema_class)
 
     Lighthouse::GraphQL::SchemaGenerator.build(
@@ -24,12 +24,9 @@ module Lighthouse::GraphQL::SchemaFactory
     )
   end
 
-  # The SDL in `sdl_folder` (default: Config.sdl_folder), or the bundled
-  # schema.graphql when there is no such folder.
-  def load_sdl(sdl_folder)
-    folder = sdl_folder || (Lighthouse::GraphQL::Config.sdl_folder if defined?(Lighthouse::GraphQL::Config))
-    return Lighthouse::GraphQL::SDLLoader.load_from_folder(folder) if folder && Dir.exist?(folder)
-
-    File.read(File.expand_path('../../schema.graphql', __dir__))
+  # The schema read from `schema_path` (default: Config.schema_path) and the
+  # files it imports.
+  def load_sdl(schema_path = nil)
+    Lighthouse::GraphQL::SchemaStitcher.new(schema_path || Lighthouse::Config.schema_path).schema_string
   end
 end