lighthouse-graphql 0.5.0 → 0.7.0

data/lib/lighthouse/directives/arguments/where_conditions_base.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+# What @whereConditions and @whereHasConditions share, as PHP Lighthouse's
+# WhereConditionsBaseDirective: an argument written with the `_` placeholder
+# gets the input types the directive generates (Lighthouse::WhereConditions::Types),
+# and the client's value becomes WHERE conditions on the field's query
+# (Lighthouse::WhereConditions::Handler).
+#
+#   type Query {
+#     people(where: _ @whereConditions(columns: ["age", "type"])): [Person!]! @all
+#     users(hasPosts: _ @whereHasConditions(columns: ["title"])): [User!]! @all
+#   }
+#
+# `columns:` restricts the columns to an enum generated from them,
+# `columnsEnum:` to an enum of the schema's; without either the column is any
+# identifier the client sends.
+class Lighthouse::GraphQL::Directives::Arguments::WhereConditionsBase < Lighthouse::GraphQL::Directives::Arguments::Base
+  include Lighthouse::Contracts::ArgManipulator
+
+  GeneratedTypes = Lighthouse::GraphQL::Directives::GeneratedTypes
+
+  COLUMN_ARGUMENTS = <<~GRAPHQL.chomp
+    """
+    Restrict the allowed column names to a well-defined list.
+    This improves introspection capabilities and security.
+    Mutually exclusive with `columnsEnum`.
+    """
+    columns: [String!]
+
+    """
+    Use an existing enumeration type to restrict the allowed columns to a predefined list.
+    This allows you to re-use the same enum for multiple fields.
+    Mutually exclusive with `columns`.
+    """
+    columnsEnum: String
+
+    """
+    A class that applies the client given conditions to the query: `call(relation, conditions)`
+    answers the relation. "Class@method" names another method. Looked up in the builders namespaces.
+    """
+    handler: String
+  GRAPHQL
+
+  # The argument, typed with the conditions input generated for it.
+  def manipulate_arg_definition(document_ast, field, type)
+    path = "the `#{@arg_node.name}` argument of #{type.name}.#{field.name}"
+    arg = GeneratedTypes.describe(@arg_node, self.class::DESCRIPTION)
+    types = Lighthouse::WhereConditions::Types
+    unless GeneratedTypes.allowed_columns?(@directive_node)
+      types.define_default(document_ast)
+      return GeneratedTypes.replace_placeholder(arg, types::DEFAULT)
+    end
+
+    name = GeneratedTypes.qualified_arg_type(@arg_node, field, type) + self.class::SUFFIX
+    types.define(document_ast, name, GeneratedTypes.columns_enum(document_ast, @directive_node, @arg_node, field, type), path)
+    GeneratedTypes.replace_placeholder(arg, name)
+  end
+
+  def handle_builder(relation, value)
+    return relation if value.nil?
+
+    handler.call(relation, conditions(value)) || relation
+  end
+
+  private
+
+  def conditions(value) = value
+
+  # Lighthouse::WhereConditions::Handler, or the class (or instance) `handler:` names.
+  def handler
+    reference = Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'handler')
+    return Lighthouse::WhereConditions::Handler unless reference
+
+    class_name, method_name = reference.to_s.split('@', 2)
+    klass = Lighthouse::Support::ModelResolver.constantize(class_name, namespaces: Lighthouse::Config.namespaces[:builders])
+    raise Lighthouse::DefinitionError, "@#{@directive_node.name}(handler: \"#{reference}\"): no class #{class_name}" unless klass
+
+    method_name = method_name.presence || 'call'
+    receiver = klass.respond_to?(method_name) ? klass : klass.new
+    receiver.method(method_name)
+  end
+end

data/lib/lighthouse/directives/arguments/where_has_conditions.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'where_conditions_base'
+
+# @whereHasConditions: the records with a related record matching the
+# client's conditions.
+#
+#   users(hasPosts: _ @whereHasConditions(columns: ["title"])): [User!]! @all
+#   { users(hasPosts: { column: TITLE, value: "Notes" }) { name } }
+class Lighthouse::GraphQL::Directives::Arguments::WhereHasConditions < Lighthouse::GraphQL::Directives::Arguments::WhereConditionsBase
+  SUFFIX = 'WhereHasConditions'
+  DESCRIPTION = 'Filter results by related records conditions.'
+
+  DEFINITION = <<~GRAPHQL.chomp
+    """
+    Allows clients to filter a query based on the existence of a related model, using
+    a dynamically controlled `WHERE` condition that applies to the relationship.
+    """
+    directive @whereHasConditions(
+      """
+      The relationship that the conditions will be applied to.
+      This argument can be omitted if the argument name follows the naming
+      convention `has{$RELATION}`. For example, if the relationship
+      is named `posts`, the argument name must be `hasPosts`.
+      """
+      relation: String
+
+    #{COLUMN_ARGUMENTS.gsub(/^/, '  ')}
+    ) on ARGUMENT_DEFINITION
+  GRAPHQL
+
+  def self.directive_name = 'whereHasConditions'
+
+  def self.definition = DEFINITION
+
+  private
+
+  # The records with at least one related record matching the value (`{}`: any related record).
+  def conditions(value)
+    condition = value.respond_to?(:to_h) ? value.to_h : value
+    {
+      has: {
+        relation: relation_name,
+        operator: Lighthouse::WhereConditions::Types::DEFAULT_HAS_OPERATOR,
+        amount: Lighthouse::WhereConditions::Types::DEFAULT_HAS_AMOUNT,
+        condition: condition.presence
+      }
+    }
+  end
+
+  # `relation:`, else the argument name without its `has` prefix: hasPosts -> posts.
+  def relation_name
+    Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'relation') ||
+      @arg_node.name.sub(/\Ahas(?=[A-Z_])/, '').then { |name| name[0].downcase + name[1..] }
+  end
+end

data/lib/lighthouse/directives/definitions.rb

@@ -31,7 +31,6 @@ module Lighthouse::GraphQL::Directives::Definitions
       graphql::Directives::NodeDirective::DEFINITIONS,
       graphql::Directives::ModelDirective::DEFINITIONS,
       graphql::Directives::VisibilityDirective::DEFINITIONS,
-      graphql::Directives::WhereConditionsDirective::DEFINITIONS,
       graphql::Directives::SoftDeletesDirective::DEFINITIONS
     ].reduce(:merge)
   end

data/lib/lighthouse/directives/generated_types.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+# What the argument manipulators that generate types share, as PHP
+# Lighthouse's ASTHelper and GeneratesColumnsEnum: the qualified name of an
+# argument's types, the enum of its allowed columns, and the `_` placeholder
+# the argument is written with.
+#
+#   type Query { posts(orderBy: _ @orderBy(columns: ["posted_at"])): [Post!]! @all }
+#
+# names Query.posts(orderBy:)'s types QueryPostsOrderBy..., its columns enum
+# QueryPostsOrderByColumn { POSTED_AT @enum(value: "posted_at") }.
+module Lighthouse::GraphQL::Directives::GeneratedTypes
+  PLACEHOLDER = '_'
+
+  module_function
+
+  # Studly(Type) + Studly(field) + Studly(argument): QueryPostsOrderBy.
+  def qualified_arg_type(arg, field, type)
+    [type.name, field.name, arg.name].map { |name| studly(name) }.join
+  end
+
+  def studly(name)
+    name.to_s.split(/[_\s-]+/).map { |part| part[0].to_s.upcase + part[1..].to_s }.join
+  end
+
+  # `argument` of the directive as a Ruby value (`columns: ["a"]` -> ["a"]), or nil.
+  def directive_value(directive, name)
+    Lighthouse::Support::DirectiveArgs.literal(directive, name)
+  end
+
+  def directive_argument?(directive, name)
+    directive.arguments.any? { |argument| argument.name == name }
+  end
+
+  # Raises unless at most one of `names` is given to the directive.
+  def mutually_exclusive!(directive, names)
+    given = names.select { |name| directive_argument?(directive, name) }
+    return if given.size <= 1
+
+    raise Lighthouse::DefinitionError,
+          "The @#{directive.name} directive can only have one of the following arguments: #{names.map { |n| "`#{n}`" }.join(', ')}."
+  end
+
+  # Does the directive restrict the columns (`columns:` or `columnsEnum:`)?
+  def allowed_columns?(directive)
+    mutually_exclusive!(directive, %w[columns columnsEnum])
+    directive_argument?(directive, 'columns') || directive_argument?(directive, 'columnsEnum')
+  end
+
+  # The enum of the allowed columns: `columnsEnum:`, or one generated from
+  # `columns:` as <QualifiedArgType>Column.
+  def columns_enum(document_ast, directive, arg, field, type)
+    enum = directive_value(directive, 'columnsEnum')
+    return enum if enum
+
+    name = "#{qualified_arg_type(arg, field, type)}Column"
+    define_columns_enum(document_ast, name, directive_value(directive, 'columns'), "#{type.name}.#{field.name}.#{arg.name}")
+    name
+  end
+
+  def define_columns_enum(document_ast, name, columns, path)
+    values = Array(columns).map { |column| %(  #{enum_value_name(column)} @enum(value: "#{column}")) }.uniq
+    document_ast.put_type(parse(<<~GRAPHQL))
+      "Allowed column names for #{path}."
+      enum #{name} {
+      #{values.join("\n")}
+      }
+    GRAPHQL
+  end
+
+  # `posted_at` -> POSTED_AT, `roles.id` -> ROLES_ID.
+  def enum_value_name(column)
+    name = column.to_s.gsub(/[^0-9A-Za-z_]/, '_').upcase
+    name.match?(/\A[0-9]/) ? "_#{name}" : name
+  end
+
+  # The argument with its type replaced by `type_string` ("[QueryPostsOrderByClause!]"),
+  # when it is written with the `_` placeholder. An argument given a type of
+  # its own keeps it.
+  def replace_placeholder(arg, type_string)
+    return arg unless placeholder?(arg.type)
+
+    arg.merge(type: parse_type(type_string))
+  end
+
+  def placeholder?(type)
+    type = type.of_type while type.respond_to?(:of_type)
+    type.name == PLACEHOLDER
+  end
+
+  # The argument with `description`, unless it has one.
+  def describe(arg, description)
+    arg.description.to_s.empty? ? arg.merge(description: description) : arg
+  end
+
+  def parse(sdl)
+    ::GraphQL::Language::Parser.parse(sdl).definitions.first
+  end
+
+  def parse_type(type_string)
+    parse("input LighthouseTypeReference { field: #{type_string} }").fields.first.type
+  end
+end

data/lib/lighthouse/directives/registry.rb

@@ -13,7 +13,9 @@
 #
 # A registered class is classified as a field resolver when it includes
 # Contracts::FieldResolver OR responds to the legacy `#define_resolver`
-# instance method.
+# instance method. A class including Contracts::ArgManipulator also rewrites
+# its arguments while the schema is built (ASTBuilder), and one including
+# Contracts::FieldBuilder constrains its fields' queries.
 class Lighthouse::DirectiveRegistry
   class << self
     def default
@@ -29,6 +31,8 @@ class Lighthouse::DirectiveRegistry
   def initialize
     @resolution = {}
     @arg_builders = {}
+    @arg_manipulators = {}
+    @field_builders = {}
     @sdl_manipulators = []
     @definitions = {}
     @type_definitions = {}
@@ -42,11 +46,7 @@ class Lighthouse::DirectiveRegistry
       name = name_or_klass
     end
 
-    if arg_builder?(klass)
-      @arg_builders[name.to_s] = klass
-    elsif resolver?(klass)
-      @resolution[name.to_s] = klass
-    end
+    classify(name.to_s, klass)
     self
   end
 
@@ -97,6 +97,21 @@ class Lighthouse::DirectiveRegistry
     @arg_builders.keys
   end
 
+  # Argument directives that rewrite their argument while the schema is built
+  # (@whereConditions, @whereHasConditions, @orderBy), as ASTBuilder applies them.
+  def arg_manipulator_class(name)
+    @arg_manipulators[name.to_s]
+  end
+
+  def arg_manipulator_classes
+    @arg_manipulators.values
+  end
+
+  # Field directives that constrain the field's query (@orderBy on a field).
+  def field_builder_class(name)
+    @field_builders[name.to_s]
+  end
+
   # SDL `directive @name(...) on ...` definitions contributed by registered,
   # self-describing directive classes. The generator injects these so the app
   # does not have to hand-declare every directive it uses.
@@ -193,7 +208,7 @@ class Lighthouse::DirectiveRegistry
 
   # Argument-builder filter/sort directives.
   ARG_BUILDERS = %i[
-    Eq Neq In NotIn Like Where WhereKey OrderBy Trashed WithoutGlobalScopes
+    Eq Neq In NotIn Like Where WhereKey OrderBy WhereConditions WhereHasConditions Trashed WithoutGlobalScopes
     WhereNull WhereNotNull WhereBetween WhereNotBetween WhereJsonContains Scope Limit
   ].freeze
 
@@ -205,11 +220,11 @@ class Lighthouse::DirectiveRegistry
 
     # 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.
+    # which names the model of fields @paginate then rewrites. The argument
+    # manipulators (@whereConditions, @orderBy, ...) run after all of them.
     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)
 
@@ -232,8 +247,22 @@ class Lighthouse::DirectiveRegistry
     nil
   end
 
+  def classify(name, klass)
+    if arg_builder?(klass)
+      @arg_builders[name] = klass
+    elsif resolver?(klass)
+      @resolution[name] = klass
+    end
+    @arg_manipulators[name] = klass if includes?(klass, Lighthouse::Contracts::ArgManipulator)
+    @field_builders[name] = klass if includes?(klass, Lighthouse::Contracts::FieldBuilder)
+  end
+
   def arg_builder?(klass)
-    klass.respond_to?(:include?) && klass.include?(Lighthouse::Contracts::ArgBuilder)
+    includes?(klass, Lighthouse::Contracts::ArgBuilder)
+  end
+
+  def includes?(klass, contract)
+    klass.respond_to?(:include?) && klass.include?(contract)
   end
 
   def resolver?(klass)

data/lib/lighthouse/document_ast.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+# The schema document as the manipulation phase works on it, as PHP
+# Lighthouse's DocumentAST: the type definitions by name, the type extensions
+# by the name they extend, the directive definitions and the schema
+# definition/extensions.
+#
+# A type is defined once. A second definition of the same name is an error,
+# not a merge: add to a type from another file with `extend type` (or
+# `extend input`, `extend enum`, ...), which ASTBuilder merges into it.
+#
+# graphql-ruby's nodes are immutable, so a manipulation replaces a type with
+# `put_type(type.merge(...))` rather than editing it.
+class Lighthouse::GraphQL::DocumentAST
+  Nodes = ::GraphQL::Language::Nodes
+
+  # The SDL keyword each kind of definition is extended with.
+  KEYWORDS = {
+    Nodes::ObjectTypeDefinition => 'type',
+    Nodes::InterfaceTypeDefinition => 'interface',
+    Nodes::InputObjectTypeDefinition => 'input',
+    Nodes::EnumTypeDefinition => 'enum',
+    Nodes::UnionTypeDefinition => 'union',
+    Nodes::ScalarTypeDefinition => 'scalar'
+  }.freeze
+
+  EXTENSIONS = [
+    Nodes::ObjectTypeExtension, Nodes::InterfaceTypeExtension, Nodes::InputObjectTypeExtension,
+    Nodes::EnumTypeExtension, Nodes::UnionTypeExtension, Nodes::ScalarTypeExtension
+  ].freeze
+
+  attr_reader :types, :type_extensions, :directives, :schema_definitions
+
+  def self.from_source(sdl)
+    document = begin
+      ::GraphQL::Language::Parser.parse(sdl.to_s)
+    rescue ::GraphQL::ParseError => e
+      raise Lighthouse::DefinitionError, "The schema is not valid GraphQL: #{e.message}"
+    end
+    from_document(document)
+  end
+
+  def self.from_document(document)
+    new.tap { |ast| document.definitions.each { |definition| ast.add(definition) } }
+  end
+
+  def initialize
+    @types = {}
+    @type_extensions = Hash.new { |hash, name| hash[name] = [] }
+    @directives = {}
+    @schema_definitions = []
+  end
+
+  def add(definition)
+    case definition
+    when *KEYWORDS.keys then add_type(definition)
+    when *EXTENSIONS then @type_extensions[definition.name] << definition
+    when Nodes::DirectiveDefinition then add_directive(definition)
+    when Nodes::SchemaDefinition, Nodes::SchemaExtension then @schema_definitions << definition
+    else raise Lighthouse::DefinitionError, "Unknown definition type: #{definition.class}"
+    end
+  end
+
+  # Adds a type, or replaces the definition of the same name.
+  def put_type(definition)
+    @types[definition.name] = definition
+    self
+  end
+
+  # Adds the type parsed from `sdl`, unless the document has a type of that name.
+  def define_type(name, sdl = nil)
+    return @types[name] if @types.key?(name)
+
+    definition = ::GraphQL::Language::Parser.parse(sdl || yield).definitions.first
+    put_type(definition)
+    definition
+  end
+
+  def type?(name) = @types.key?(name)
+
+  # The names of the types, as they are now: manipulators add types while
+  # ASTBuilder goes over these.
+  def type_names = @types.keys
+
+  def to_document
+    Nodes::Document.new(definitions: @schema_definitions + @directives.values + @types.values + @type_extensions.values.flatten)
+  end
+
+  def to_sdl
+    ::GraphQL::Language::Printer.new.print(to_document)
+  end
+
+  private
+
+  def add_type(definition)
+    if @types.key?(definition.name)
+      keyword = KEYWORDS.fetch(definition.class)
+      raise Lighthouse::DefinitionError,
+            "Duplicate definition #{definition.name} found when parsing the schema. Define a type once and add to it " \
+            "from other files with `extend #{keyword} #{definition.name}`."
+    end
+
+    @types[definition.name] = definition
+  end
+
+  def add_directive(definition)
+    raise Lighthouse::DefinitionError, "Duplicate definition @#{definition.name} found when parsing the schema." if @directives.key?(definition.name)
+
+    @directives[definition.name] = definition
+  end
+end

data/lib/lighthouse/field_resolver_stack.rb

@@ -55,20 +55,23 @@ 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.
+  # What resolves a field with no resolving directive: the method of the
+  # type's class (Types::QueryType#latest_posts too, as in graphql-ruby), else
+  # for a Query or Mutation field the conventional 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
+    return convention_step(type, field_def, root_kind, bases) if root_kind == :subscriptions
 
-    type_method_step(type, field_def, type_class) if type_class
+    step = type_method_step(type, field_def, type_class, root: !root_kind.nil?) if type_class
+    step || (convention_step(type, field_def, root_kind, bases) if root_kind)
   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)
+  # `root`: the class is the root type's, which the type is built on, not one found by name.
+  def type_method_step(type, field_def, type_class, root: false)
     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
+    [0, -> { resolver.new(field_def, type, method_name, root ? type_class : nil).define_resolver(type) }] if method_name
   end
 
   # An explicit @validator on the field already validates its arguments.

data/lib/lighthouse/global_id.rb

@@ -7,6 +7,12 @@ require 'base64'
 # 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.
+#
+# A schema that implements graphql-ruby's Relay ids, `id_from_object` and
+# `object_from_id` (graphql-ruby's install writes them, on Rails' GlobalID),
+# has one kind of global id: @globalId encodes an object's own id with
+# `id_from_object`, and decodes with `object_from_id`, as graphql-ruby's
+# Query.node and Node's `id` do.
 module Lighthouse::GraphQL::GlobalId
   module_function
 
@@ -20,12 +26,32 @@ module Lighthouse::GraphQL::GlobalId
     []
   end
 
-  # [type, id] for a global id a client sent, through Config.global_id; a
+  # [type, id] for a global id a client sent, through the schema's
+  # object_from_id (schema_ids?) or Config.global_id; a
   # GraphQL::ExecutionError when it is not one.
-  def decode!(global_id)
-    type, id = Lighthouse::Config.global_id.decode(global_id)
+  def decode!(global_id, context = nil)
+    type, id = schema_ids?(context&.schema) ? decode_object(global_id, context) : 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
+
+  # The global id of `object`'s own id (`id`, what a field of `type` resolved)
+  # through the schema's id_from_object (schema_ids?); nil for anything else.
+  def encode_field(type, object, id, context)
+    return unless schema_ids?(context&.schema) && object.respond_to?(:id) && object.id.to_s == id.to_s
+
+    context.schema.id_from_object(object, type, context)
+  end
+
+  # Does `schema` define graphql-ruby's object_from_id (GraphQL::Schema's own raises)?
+  def schema_ids?(schema)
+    schema.respond_to?(:object_from_id) && schema.method(:object_from_id).owner != ::GraphQL::Schema.singleton_class
+  end
+
+  # [type, id] of the object the schema's object_from_id finds.
+  def decode_object(global_id, context)
+    object = context.schema.object_from_id(global_id, context)
+    object.nil? ? [] : [object.class.name.demodulize, object.id]
+  end
 end

data/lib/lighthouse/graphql/version.rb

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

data/lib/lighthouse/graphql_ruby_patches.rb

@@ -15,4 +15,49 @@ module Lighthouse::GraphQL
   # skip the fix rather than fail to load (explicit nulls then fail as before).
   builder = ::GraphQL::Schema::BuildFromDefinition.const_get(:Builder) if ::GraphQL::Schema::BuildFromDefinition.const_defined?(:Builder)
   builder.prepend(NullDirectiveArguments) if builder && (builder.method_defined?(:args_to_kwargs) || builder.private_method_defined?(:args_to_kwargs))
+
+  # graphql-ruby builds every SDL object type on base_types[:object], and every
+  # interface from base_types[:interface]. RootTypes builds a root type on the
+  # app's code-first one (Types::QueryType) instead, and takes the app's Node
+  # interface (Types::NodeType) as the SDL's Node.
+  module RootTypeBuilder
+    def build_object_type(definition, type_resolver, base_type)
+      root = Lighthouse::GraphQL::RootTypes.base_for(definition.name)
+      return super unless root
+
+      super(Lighthouse::GraphQL::RootTypes.definition_on(definition, root), type_resolver, root)
+    end
+
+    def build_interface_type(definition, type_resolver, base_type)
+      Lighthouse::GraphQL::RootTypes.base_for(definition.name) || super
+    end
+  end
+
+  # As above, a graphql-ruby release that reshapes the builder skips the hook:
+  # root types are then built on base_types[:object], as before.
+  if builder && %i[build_object_type build_interface_type].all? { |name| builder.method_defined?(name) || builder.private_method_defined?(name) }
+    builder.prepend(RootTypeBuilder)
+  end
+
+  # The app's schema class inherits Lighthouse's (`class AppSchema <
+  # get_schema(...)`), so its Subscription root type is the parent's. A
+  # subscriptions backend the subclass `use`s (ActionCableSubscriptions) then
+  # finds no root type of the subclass's own, and graphql-ruby adds its
+  # subscription extension to no field. Look the root type up through the
+  # parent too. Extended onto the schemas Lighthouse builds (SchemaGenerator).
+  module InheritedSubscriptionRoot
+    def add_subscription_extension_if_necessary
+      return super if @subscription_object.is_a?(Class) || !defined?(::GraphQL::Subscriptions::DefaultSubscriptionResolveExtension)
+      return unless inherited_subscription_root_pending?
+
+      @subscription_extension_added = true
+      extension = ::GraphQL::Subscriptions::DefaultSubscriptionResolveExtension
+      subscription.all_field_definitions.each { |field| field.extension(extension) unless field.extensions.any?(extension) }
+    end
+
+    # A backend, a root type from the parent, and no extension added yet.
+    def inherited_subscription_root_pending?
+      !defined?(@subscription_extension_added) && subscription.is_a?(Class) && !subscriptions.nil?
+    end
+  end
 end