lighthouse-graphql 0.3.0 → 0.5.0

data/lib/lighthouse/directive_resolvers/namespaced_resolver.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+# @namespaced — a field that only groups others, as PHP Lighthouse's
+# directive: it resolves to `true`, and the fields of its type resolve with
+# their own directives.
+#
+#   type Query { post: PostQueries! @namespaced }
+#   type PostQueries {
+#     find(id: ID! @eq): Post @find
+#     list: [Post!]! @paginate
+#   }
+#
+# `{ post { find(id: 1) { title } } }`. Works on Mutation too.
+class Lighthouse::GraphQL::DirectiveResolvers::NamespacedDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'namespaced'
+
+  def self.definition
+    <<~GRAPHQL.chomp
+      """
+      A no-op field resolver that allows nesting of queries and mutations.
+      """
+      directive @namespaced on FIELD_DEFINITION
+    GRAPHQL
+  end
+
+  def define_resolver(target_type_class)
+    install(target_type_class, ->(_obj, _args, _ctx) { true })
+  end
+end

data/lib/lighthouse/directive_resolvers/paginate_resolver.rb

@@ -75,7 +75,7 @@ class Lighthouse::GraphQL::DirectiveResolvers::PaginateDirectiveResolver < Light
   # `scopes:`, @builder and the argument filters, on one relation or a RelationBatch.
   def decorate_relation(relation, args, ctx)
     relation = Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply(apply_scopes(relation), @field_def.ast_node, args, ctx, self)
-    apply_where_filters(relation, args)
+    apply_where_filters(relation, args, ctx)
   end
 
   protected

data/lib/lighthouse/directive_resolvers/resolution.rb

@@ -18,15 +18,30 @@ module Lighthouse::GraphQL::DirectiveResolvers::Resolution
         original_singleton.call(obj, arguments, ctx)
       elsif original_proc
         original_proc.call(obj, arguments, ctx)
-      elsif obj.respond_to?(field_name)
-        obj.public_send(field_name)
       else
-        snake = Lighthouse::Support::Naming.attribute(field_name)
-        obj.respond_to?(snake) ? obj.public_send(snake) : nil
+        Lighthouse::GraphQL::DirectiveResolvers::Resolution.read(obj, field_name)
       end
     end
   end
 
+  # The default reader: a Hash's key, else the object's method of the field's
+  # name or its snake_case.
+  def read(obj, field_name)
+    return read_hash(obj, field_name) if obj.is_a?(Hash)
+    return obj.public_send(field_name) if obj.respond_to?(field_name)
+
+    snake = Lighthouse::Support::Naming.attribute(field_name)
+    obj.respond_to?(snake) ? obj.public_send(snake) : nil
+  end
+
+  # A Hash's value for the field, as the default reader finds it: by the field's
+  # name or its snake_case, as a String or a Symbol key.
+  def read_hash(hash, field_name)
+    snake = Lighthouse::Support::Naming.attribute(field_name)
+    key = [field_name.to_s, field_name.to_sym, snake, snake.to_sym].find { |candidate| hash.key?(candidate) }
+    key.nil? ? nil : hash[key]
+  end
+
   # graphql-ruby's SDL builder defines `resolve_field_*` methods of its own
   # (with a different arity); only ours, defined under lib/lighthouse/, count.
   def lighthouse_singleton(target_type_class, method_name)

data/lib/lighthouse/directive_resolvers/subscription_resolver.rb

@@ -8,8 +8,9 @@ require_relative 'base'
 # Config.namespaces[:subscriptions] at call time so code reloading keeps
 # working. The class is a GraphQL::Schema::Subscription, which may include
 # Lighthouse::GraphQL::Subscription for PHP Lighthouse's hooks. A field
-# with no class still works: it is a Lighthouse::GraphQL::Subscription::Default
-# whose update is the broadcast root, which is all `@broadcast` needs.
+# with no class still works: it resolves with the schema's base_types[:subscription]
+# when given, else with Lighthouse::GraphQL::Subscription::Default, whose update
+# is the broadcast root, which is all `@broadcast` needs.
 #
 # graphql-ruby registers a subscription through the class its field was
 # built from, which a field built from SDL has not. The field is therefore
@@ -31,27 +32,35 @@ class Lighthouse::GraphQL::DirectiveResolvers::SubscriptionDirectiveResolver < L
     @field_def.define_singleton_method(:subscription_scope) { me.subscription_class.subscription_scope }
 
     install(target_type_class, lambda do |obj, args, ctx|
-      Lighthouse::GraphQL::ResolverDispatch.call(me.subscription_class, me.field_def, obj, args, ctx)
+      info = Lighthouse::GraphQL::ResolveInfo.for(me.field_def, target_type_class, obj, args, ctx)
+      Lighthouse::GraphQL::ResolverDispatch.call(me.subscription_class, info)
     end)
   end
 
   attr_reader :field_def
 
   # The class this field stands for: the one @subscription names, else the
-  # conventional one, else the default.
+  # conventional one, else the schema's base subscription, else the default.
   def subscription_class
     klass = find_class
-    return Lighthouse::GraphQL::Subscription::Default unless klass
+    return base || Lighthouse::GraphQL::Subscription::Default unless klass
 
     unless klass.is_a?(Class) && klass < ::GraphQL::Schema::Subscription
       raise Lighthouse::DefinitionError, "#{klass} resolves #{location}, so it must inherit from GraphQL::Schema::Subscription."
     end
 
+    Lighthouse::GraphQL::ResolverBases.check!(klass, base, location)
+
     klass
   end
 
   private
 
+  # The schema's base_types[:subscription], or nil.
+  def base
+    (@opts[:bases] || {})[:subscriptions]
+  end
+
   def find_class
     namespaces = Lighthouse::Config.namespaces[:subscriptions]
     named = directive_arg('class') if @directive_node

data/lib/lighthouse/directive_resolvers/throttle_resolver.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+# @throttle — rate-limit a field per client, as PHP Lighthouse's directive (and
+# Laravel's ThrottleRequests): at most `maxAttempts` calls every `decayMinutes`,
+# counted in Config.cache_store. A client is the signed-in user, else the
+# context's :remote_ip (Lighthouse::GraphQL::Controller sets it), else "guest".
+# Past the limit the field fails with "Rate limit for Query.x exceeded. Try
+# again later." Outermost: refused calls never reach @guard or the resolver.
+#
+#   type Mutation {
+#     login(email: String!, password: String!): User @throttle(maxAttempts: 5)
+#     search(term: String!): [Post!]! @throttle(name: "search", maxAttempts: 30, decayMinutes: 0.5)
+#   }
+class Lighthouse::GraphQL::DirectiveResolvers::ThrottleDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'throttle'
+
+  def self.definition
+    <<~GRAPHQL.chomp
+      """
+      Sets rate limit to access the field. Does the same as ThrottleRequests Laravel Middleware.
+      """
+      directive @throttle(
+        "A name shared by the fields that count together. Defaults to the field."
+        name: String
+        "Maximum number of attempts in a specified time interval."
+        maxAttempts: Int = 60
+        "Time in minutes to reset attempts."
+        decayMinutes: Float = 1.0
+        "Prefix to distinguish several field groups."
+        prefix: String
+      ) on FIELD_DEFINITION
+    GRAPHQL
+  end
+
+  def define_resolver(target_type_class)
+    me = self
+    inner = capture_inner(target_type_class)
+    location = "#{target_type_class.graphql_name}.#{@field_def.name}"
+    bucket = "#{directive_arg('prefix')}#{directive_arg('name') || location}"
+    max_attempts = directive_arg('maxAttempts') || 60
+    decay = ((directive_arg('decayMinutes') || 1.0) * 60).ceil
+
+    install(target_type_class, lambda do |obj, args, ctx|
+      me.hit!(bucket, ctx, max_attempts, decay, location)
+      inner.call(obj, args, ctx)
+    end)
+  end
+
+  def hit!(bucket, ctx, max_attempts, decay, location)
+    key = "lighthouse:throttle:#{bucket}:#{client(ctx)}"
+    store = Lighthouse::GraphQL::Caching.store
+    self.class.warn_null_store(location) if store.is_a?(::ActiveSupport::Cache::NullStore)
+    attempts = store.increment(key, 1, expires_in: decay) || (store.write(key, 1, expires_in: decay) && 1)
+    raise ::GraphQL::ExecutionError, "Rate limit for #{location} exceeded. Try again later." if attempts > max_attempts
+  end
+
+  # A :null_store keeps no count, so the limit never applies: say so, once per field.
+  def self.warn_null_store(location)
+    @warned ||= Set.new
+    return unless @warned.add?(location)
+
+    message = "Lighthouse: @throttle on #{location} counts nothing, as the cache store is a :null_store. Set Config.cache_store."
+    defined?(Rails) && Rails.logger ? Rails.logger.warn(message) : warn(message)
+  end
+
+  private
+
+  def client(ctx)
+    user = Lighthouse::Support::Authorization.authenticated_user(ctx)
+    return "user:#{user.respond_to?(:id) ? user.id : user}" if user
+
+    ip = ctx.respond_to?(:[]) ? ctx[:remote_ip] : nil
+    ip ? "ip:#{ip}" : 'guest'
+  end
+end

data/lib/lighthouse/directive_resolvers/type_method_resolver.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+# Resolves a field of an object type through a method of the type's class, in
+# graphql-ruby's folder structure: `Post.readingTime` calls
+# `Types::PostType#reading_time` when that class includes Lighthouse::GraphQL::Type
+# and defines it. The SDL still declares the field; the class only says how it
+# resolves, as a graphql-ruby type's method does: an instance per parent, with
+# `object` (the parent), `context`, the `dataload*` helpers, and the field's
+# arguments as snake_case keywords. A field with a resolving directive never
+# reaches it, and one whose name the class does not define is read off the
+# object as before. Not a directive: FieldResolverStack installs it on types
+# other than the root ones.
+class Lighthouse::GraphQL::DirectiveResolvers::TypeMethodResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  # The class of the SDL type `type_name` (`Types::PostType` for `Post`) in
+  # Config.namespaces[:types], when it includes Lighthouse::GraphQL::Type; nil
+  # otherwise, so a type class that does not opt in is left alone. It must
+  # inherit from the schema's base_types[:object] (in `bases`, ResolverBases)
+  # when one is given.
+  def self.type_class(type_name, bases = {})
+    klass = lookup(type_name)
+    return unless klass
+
+    Lighthouse::GraphQL::ResolverBases.check!(klass, bases.dig(:types, :object), "the #{type_name} type")
+    klass
+  end
+
+  def self.lookup(type_name)
+    Lighthouse::GraphQL::Type.class_for(type_name, :object)
+  end
+
+  # The method of `klass` that resolves `field_def` (`reading_time` for
+  # `readingTime`), or nil. Methods every GraphQL::Schema::Object has
+  # (`object`, `context`, Object's own) never count.
+  def self.method_for(klass, field_def)
+    name = Lighthouse::Support::Naming.attribute(field_def.name)
+    name if klass.public_method_defined?(name) && !::GraphQL::Schema::Object.public_method_defined?(name)
+  end
+
+  def initialize(field_def, type_def, method_name)
+    super(field_def, type_def, nil)
+    @method_name = method_name
+  end
+
+  def define_resolver(target_type_class)
+    Lighthouse::GraphQL::ResolveInfo.request_lookahead(@field_def)
+    me = self
+    inner = capture_inner(target_type_class)
+
+    install(target_type_class, lambda do |obj, args, ctx|
+      me.send(:resolve_with_type, inner, obj, args, ctx)
+    end)
+  end
+
+  private
+
+  # The class is looked up on each call, so code reloading keeps working; when
+  # it no longer defines the method, the field is read as before. A parent that
+  # is not a record of the type's @model is reported, and the field resolves to nil.
+  def resolve_with_type(inner, obj, args, ctx)
+    klass = self.class.lookup(@type_def.graphql_name)
+    return inner.call(obj, args, ctx) unless klass&.public_method_defined?(@method_name)
+
+    model = Lighthouse::GraphQL::Directives::ModelDirective.declared_model(@type_def)
+    return wrong_parent(klass, model, obj, ctx) if model && !obj.is_a?(model)
+
+    info = Lighthouse::GraphQL::ResolveInfo.for(@field_def, @type_def, obj, args, ctx)
+    instance = Lighthouse::GraphQL::ResolveInfo.attach(klass.send(:new, obj, ctx), info)
+    kwargs = Lighthouse::Support::Arguments.prepare(@field_def, args, ctx)
+    kwargs.empty? ? instance.public_send(@method_name) : instance.public_send(@method_name, **kwargs)
+  end
+
+  def wrong_parent(klass, model, obj, ctx)
+    error = Lighthouse::DefinitionError.new(
+      "#{@type_def.graphql_name}.#{@field_def.name} resolves with #{klass}, but its parent is a #{obj.class}, not a #{model} (@model)."
+    )
+    Lighthouse::Config.handle_error(error, ctx)
+    nil
+  end
+end

data/lib/lighthouse/directive_resolvers/with_count_resolver.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+# @withCount(relation: "posts", scopes: [...]) — count a relation of the parent
+# before the field resolves, as PHP Lighthouse's @withCount does: the count is not
+# the field's value, it is kept on the parent as `<relation>_count`
+# (`user.posts_count`) for whatever resolves the field to read. Every parent in
+# the response is counted in one query.
+#
+#   type User {
+#     activity: String! @withCount(relation: "posts") @method(name: "activity_label")
+#     postsCount: Int! @withCount(relation: "posts")   # the default reader reads posts_count
+#   }
+class Lighthouse::GraphQL::DirectiveResolvers::WithCountDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'withCount'
+
+  def self.definition
+    <<~GRAPHQL.chomp
+      """
+      Count a relation of the parent before the field resolves, for every parent at once,
+      and keep the count on it as `<relation>_count`.
+      """
+      directive @withCount(
+        "The relation to count."
+        relation: String!
+        "Model scopes that narrow the counted records."
+        scopes: [String!]
+      ) repeatable on FIELD_DEFINITION
+    GRAPHQL
+  end
+
+  def define_resolver(target_type_class)
+    inner = capture_inner(target_type_class)
+    relation = directive_arg('relation')
+    scopes = Array(directive_arg('scopes'))
+
+    install(target_type_class, lambda do |obj, args, ctx|
+      ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::RelationCountsLoader, relation, scopes).load(obj) if obj.is_a?(::ActiveRecord::Base)
+      inner.call(obj, args, ctx)
+    end)
+  end
+end

data/lib/lighthouse/directive_resolvers/with_resolver.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+# @with(relation: "tasks", scopes: [...]) — eager-load a relation of the parent
+# before the field resolves, as PHP Lighthouse's @with does: for a field computed
+# from it (a @method, a type class method, the default reader of a method that
+# reads it), so it is loaded once for every parent in the response, not once per
+# parent. `relation` defaults to the field's (snake_case) name, and may be nested
+# ("tasks.assignee"); `scopes` narrow the loaded records.
+#
+#   type User {
+#     taskSummary: String! @with(relation: "tasks") @method(name: "task_summary")
+#   }
+class Lighthouse::GraphQL::DirectiveResolvers::WithDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'with'
+
+  def self.definition
+    <<~GRAPHQL.chomp
+      """
+      Eager-load a relation of the parent before the field resolves, for every parent at once.
+      """
+      directive @with(
+        "The relation to load, nested with dots. Defaults to the field's name."
+        relation: String
+        "Model scopes that narrow the loaded records."
+        scopes: [String!]
+      ) repeatable on FIELD_DEFINITION
+    GRAPHQL
+  end
+
+  def define_resolver(target_type_class)
+    inner = capture_inner(target_type_class)
+    associations = Lighthouse::Support::Preload.associations(directive_arg('relation') || Lighthouse::Support::Naming.attribute(@field_def.name))
+    scopes = Array(directive_arg('scopes'))
+
+    install(target_type_class, lambda do |obj, args, ctx|
+      ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::PreloadLoader, associations, scopes).load(obj) if obj.is_a?(::ActiveRecord::Base)
+      inner.call(obj, args, ctx)
+    end)
+  end
+end

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

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Lighthouse::GraphQL::Directives::Arguments
+  # @whereNull — `true` keeps the rows whose column is null, `false` those whose
+  # column is not. `posts(unpublished: Boolean @whereNull(key: "published_at"))`
+  class WhereNull < Base
+    def self.directive_name = 'whereNull'
+
+    def self.definition
+      <<~GRAPHQL.chomp
+        """
+        Filter the value is null: true keeps the rows where the column is null, false the others.
+        """
+        directive @whereNull(
+          "The database column. Defaults to the argument's name."
+          key: String
+        ) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION
+      GRAPHQL
+    end
+
+    def handle_builder(relation, value)
+      return relation if value.nil?
+
+      value ? relation.where(column => nil) : relation.where.not(column => nil)
+    end
+  end
+
+  # @whereNotNull — the inverse: `true` keeps the rows whose column is not null.
+  class WhereNotNull < Base
+    def self.directive_name = 'whereNotNull'
+
+    def self.definition
+      <<~GRAPHQL.chomp
+        """
+        Filter the value is not null: true keeps the rows where the column is not null, false the others.
+        """
+        directive @whereNotNull(
+          "The database column. Defaults to the argument's name."
+          key: String
+        ) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION
+      GRAPHQL
+    end
+
+    def handle_builder(relation, value)
+      return relation if value.nil?
+
+      value ? relation.where.not(column => nil) : relation.where(column => nil)
+    end
+  end
+
+  # @whereBetween — the column lies between two values: an input object's two
+  # fields, in order, or a list of two. `createdAt: DateRange @whereBetween(key: "created_at")`
+  class WhereBetween < Base
+    def self.directive_name = 'whereBetween'
+
+    def self.definition
+      <<~GRAPHQL.chomp
+        """
+        Verify that a column's value is between two values: the argument's two input fields, in order.
+        """
+        directive @whereBetween(
+          "The database column. Defaults to the argument's name."
+          key: String
+        ) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION
+      GRAPHQL
+    end
+
+    def handle_builder(relation, value)
+      from, to = bounds(value)
+      return relation if from.nil? && to.nil?
+
+      relation.where(column => from..to)
+    end
+
+    private
+
+    def bounds(value)
+      values = value.respond_to?(:to_h) && !value.is_a?(Array) ? value.to_h.values : Array(value)
+      values.first(2)
+    end
+  end
+
+  # @whereNotBetween — the column lies outside two values.
+  class WhereNotBetween < WhereBetween
+    def self.directive_name = 'whereNotBetween'
+
+    def self.definition
+      <<~GRAPHQL.chomp
+        """
+        Verify that a column's value lies outside two values: the argument's two input fields, in order.
+        """
+        directive @whereNotBetween(
+          "The database column. Defaults to the argument's name."
+          key: String
+        ) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION
+      GRAPHQL
+    end
+
+    def handle_builder(relation, value)
+      from, to = bounds(value)
+      return relation if from.nil? && to.nil?
+
+      relation.where.not(column => from..to)
+    end
+  end
+
+  # @whereJsonContains — a JSON column contains the value (Laravel's
+  # whereJsonContains), on PostgreSQL (@>), MySQL (JSON_CONTAINS) and SQLite
+  # (json_each). `key:` may point into the document: "options->tags".
+  class WhereJsonContains < Base
+    def self.directive_name = 'whereJsonContains'
+
+    def self.definition
+      <<~GRAPHQL.chomp
+        """
+        Use an input value as a whereJsonContains filter.
+        """
+        directive @whereJsonContains(
+          "The JSON column, optionally with a path into it: \\"options->tags\\". Defaults to the argument's name."
+          key: String
+        ) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION
+      GRAPHQL
+    end
+
+    def handle_builder(relation, value)
+      return relation if value.nil?
+
+      connection = relation.connection
+      name, *path = column.to_s.split('->')
+      target = "#{connection.quote_table_name(relation.klass.table_name)}.#{connection.quote_column_name(name)}"
+      relation.where(*condition(connection.adapter_name, target, path, value))
+    end
+
+    private
+
+    def condition(adapter, target, path, value)
+      json_path = "$#{path.map { |segment| ".#{segment}" }.join}"
+      case adapter
+      when /postg/i then ["(#{target}#{path.map { |segment| "->'#{segment}'" }.join})::jsonb @> ?::jsonb", value.to_json]
+      when /mysql|trilogy/i then ["JSON_CONTAINS(#{target}, ?, ?)", value.to_json, json_path]
+      else sqlite(target, json_path, value)
+      end
+    end
+
+    # Every value of a list must be in the array, as JSON containment means.
+    def sqlite(target, json_path, value)
+      values = Array(value)
+      sql = values.map { "EXISTS (SELECT 1 FROM json_each(#{target}, ?) WHERE json_each.value = ?)" }.join(' AND ')
+      [sql, *values.flat_map { |item| [json_path, item] }]
+    end
+  end
+
+  # @limit — the argument directive behind LimitResolver. Only `builder: true`
+  # makes it one: a LIMIT on the field's query. Without it, LimitResolver cuts
+  # the results instead.
+  class Limit < Base
+    def self.directive_name = 'limit'
+
+    def self.definition
+      <<~GRAPHQL.chomp
+        """
+        Allow clients to specify the maximum number of results to return when used on an argument,
+        or statically limit them when used on a field.
+
+        By default, this directive does not influence the number of results the resolver queries internally,
+        but limits how much of it is returned to clients. Use the `builder` argument to change this.
+        """
+        directive @limit(
+          """
+          You may set this to `true` if the field uses a query builder,
+          then this directive will apply a LIMIT clause to it.
+          Typically, this option should only be used for root fields,
+          as it may cause wrong results with batched relation queries.
+          """
+          builder: Boolean! = false
+        ) on ARGUMENT_DEFINITION | FIELD_DEFINITION
+      GRAPHQL
+    end
+
+    def handle_builder(relation, value)
+      return relation unless value.is_a?(Integer) && Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'builder')
+
+      relation.limit(value)
+    end
+  end
+
+  # @scope — call a model scope with the client's value.
+  # `posts(trending: Boolean @scope)` calls Post.trending(value); `name:` names another scope.
+  class Scope < Base
+    def self.directive_name = 'scope'
+
+    def self.definition
+      <<~GRAPHQL.chomp
+        """
+        Adds a scope to the query builder.
+        The scope method will receive the client-given value of the argument as its argument.
+        """
+        directive @scope(
+          "The name of the scope. Defaults to the name of the argument."
+          name: String
+        ) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION
+      GRAPHQL
+    end
+
+    def handle_builder(relation, value)
+      return relation if value.nil?
+
+      relation.public_send(
+        Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'name') || Lighthouse::Support::Naming.attribute(@arg_node.name), value
+      )
+    end
+  end
+end

data/lib/lighthouse/directives/definitions.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# The SDL of the directives no registered resolver class contributes, and of
+# the types they refer to: the field-level query directives (@builder,
+# @whereAuth), the argument directives, the type-system ones (@union, @node,
+# @model, ...), and those the schema reads while it is built. The registry
+# injects each into a schema that uses it without declaring it.
+module Lighthouse::GraphQL::Directives::Definitions
+  # Directives that only mark the SDL for others to read.
+  PASSIVE = {
+    'nest' => 'directive @nest on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION',
+    'spread' => 'directive @spread on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION',
+    'inject' => 'directive @inject(context: String!, name: String!) repeatable on FIELD_DEFINITION',
+    'cacheKey' => 'directive @cacheKey on FIELD_DEFINITION'
+  }.freeze
+
+  module_function
+
+  # { name => "directive @name ..." }
+  def directives
+    graphql = Lighthouse::GraphQL
+    [
+      graphql::DirectiveResolvers::BuilderApplier::DEFINITIONS,
+      graphql::DirectiveResolvers::ArgumentTransformsResolver::DEFINITIONS,
+      PASSIVE,
+      { 'cacheControl' => graphql::CacheControl::DEFINITION, 'feature' => graphql::FeatureDirective::DEFINITION,
+        'complexity' => graphql::Complexity::DEFINITION, 'scalar' => graphql::ScalarCoercion::DEFINITION,
+        'enum' => graphql::EnumDirective::DEFINITION },
+      through_aliases,
+      graphql::TypeResolution::DEFINITIONS,
+      graphql::Directives::NodeDirective::DEFINITIONS,
+      graphql::Directives::ModelDirective::DEFINITIONS,
+      graphql::Directives::VisibilityDirective::DEFINITIONS,
+      graphql::Directives::WhereConditionsDirective::DEFINITIONS,
+      graphql::Directives::SoftDeletesDirective::DEFINITIONS
+    ].reduce(:merge)
+  end
+
+  # @hasManyThrough and @hasOneThrough: @hasMany's and @hasOne's definitions, renamed.
+  def through_aliases
+    resolvers = Lighthouse::GraphQL::DirectiveResolvers
+    { 'hasManyThrough' => resolvers::HasManyDirectiveResolver, 'hasOneThrough' => resolvers::HasOneDirectiveResolver }
+      .to_h { |name, klass| [name, klass.definition.sub("@#{klass.directive_name}(", "@#{name}(")] }
+  end
+
+  # { type name => its SDL }, for the types the directives above refer to.
+  def types
+    graphql = Lighthouse::GraphQL
+    [graphql::CacheControl::TYPE_DEFINITIONS, graphql::FeatureDirective::TYPE_DEFINITIONS, graphql::EnumDirective::TYPE_DEFINITIONS,
+     graphql::DirectiveResolvers::BuilderApplier::TYPE_DEFINITIONS].reduce(:merge)
+  end
+end