lighthouse-graphql 0.4.0 → 0.6.0

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

data/lib/lighthouse/directives/model_directive.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+# @model(class: "Post") — map an object type to the ActiveRecord model whose
+# records it resolves, as PHP Lighthouse's directive, for when the type's name
+# is not the model's:
+#
+#   type Article @model(class: "Post") { id: ID! title: String! }
+#
+#   type Query {
+#     articles: [Article!]! @paginate      # pages through Post
+#     article(id: ID! @eq): Article @find   # Post.find_by(id:)
+#   }
+#
+# - Every directive that takes `model:` (@all, @find, @first, @paginate, @create,
+#   @update, @upsert, @delete, @can*, ...) on a field returning the type gets it,
+#   unless it names its own: the SDL is rewritten before the schema is built.
+# - A union or interface resolves a record of the model to the type.
+# - @node finds the type's records in the model.
+# - The schema does not build unless the class is an ActiveRecord model, and a
+#   type class's methods (Types::ArticleType) only run on its records.
+class Lighthouse::GraphQL::Directives::ModelDirective
+  DEFINITIONS = {
+    'model' => <<~GRAPHQL.chomp
+      """
+      Map a model class to an object type.
+      This can be used when the name of the model differs from the name of the type.
+      """
+      directive @model(
+        "The class name of the corresponding model."
+        class: String!
+      ) on OBJECT
+    GRAPHQL
+  }.freeze
+
+  OBJECTS = [::GraphQL::Language::Nodes::ObjectTypeDefinition, ::GraphQL::Language::Nodes::ObjectTypeExtension].freeze
+
+  DECLARATION = /directive\s+@model\b/
+  USAGE = /@model\b/
+
+  def self.manipulate(sdl)
+    return sdl unless sdl.is_a?(String) && sdl.gsub(DECLARATION, '').match?(USAGE)
+
+    new(::GraphQL::Language::Parser.parse(sdl)).manipulate(sdl)
+  rescue ::GraphQL::ParseError
+    sdl
+  end
+
+  # The model class name a schema type maps to with @model, or nil.
+  def self.class_name(type)
+    directive = (type.ast_node&.directives || []).find { |d| d.name == 'model' }
+    directive && Lighthouse::Support::DirectiveArgs.literal(directive, 'class')
+  end
+
+  # The model of a schema type: the one @model names, else the one named after it.
+  def self.model_for(type)
+    Lighthouse::Support::ModelResolver.constantize(class_name(type) || type.graphql_name)
+  end
+
+  # The model @model declares on a schema type, or nil.
+  def self.declared_model(type)
+    name = class_name(type)
+    name && Lighthouse::Support::ModelResolver.constantize(name)
+  end
+
+  # Fail at build time: every @model names an ActiveRecord model.
+  def self.validate!(schema)
+    schema.types.each_value do |type|
+      name = type.kind.object? && class_name(type)
+      next unless name
+
+      model = declared_model(type)
+      next if model.is_a?(Class) && defined?(::ActiveRecord::Base) && model < ::ActiveRecord::Base
+
+      raise Lighthouse::DefinitionError, "@model(class: #{name.inspect}) on #{type.graphql_name} names no ActiveRecord model."
+    end
+  end
+
+  # The directives that take `model:` and act on a field, from the registry.
+  def self.model_directives
+    Lighthouse::DirectiveRegistry.default.directive_definitions
+                                 .select { |_, definition| definition.match?(/\bmodel:/) && definition.include?('FIELD_DEFINITION') }.keys
+  end
+
+  def initialize(document)
+    @document = document
+    @models = document.definitions.filter_map { |definition| [definition.name, model_name(definition)] if object?(definition) }
+                      .select(&:last).to_h
+    @directives = self.class.model_directives
+  end
+
+  def manipulate(sdl)
+    return sdl if @models.empty?
+
+    definitions = @document.definitions.map { |definition| object?(definition) ? with_models(definition) : definition }
+    ::GraphQL::Language::Printer.new.print(@document.merge(definitions: definitions))
+  end
+
+  private
+
+  def object?(definition)
+    OBJECTS.any? { |kind| definition.is_a?(kind) }
+  end
+
+  # The class @model names on a type definition, or nil.
+  def model_name(definition)
+    directive = definition.directives.find { |d| d.name == 'model' }
+    directive&.arguments&.find { |argument| argument.name == 'class' }&.value
+  end
+
+  def with_models(definition)
+    definition.merge(fields: definition.fields.map { |field| with_model(field) })
+  end
+
+  # The field's model directives with `model:` set to the model its return type maps to.
+  def with_model(field)
+    model = @models[unwrap(field.type).name]
+    return field unless model
+
+    field.merge(directives: field.directives.map { |directive| with_model_argument(directive, model) })
+  end
+
+  def with_model_argument(directive, model)
+    return directive unless @directives.include?(directive.name) && directive.arguments.none? { |argument| argument.name == 'model' }
+
+    directive.merge(arguments: directive.arguments + [::GraphQL::Language::Nodes::Argument.new(name: 'model', value: model)])
+  end
+
+  def unwrap(type)
+    type.respond_to?(:of_type) ? unwrap(type.of_type) : type
+  end
+end

data/lib/lighthouse/directives/node_directive.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+# @node — Relay's global object identification, as PHP Lighthouse's directive.
+# On a type, it makes the schema:
+#
+#   "Any object implementing this type can be found by ID through `Query.node`."
+#   interface Node @interface(resolveType: "Lighthouse::GraphQL::NodeRegistry") {
+#     "Global identifier that can be used to resolve any Node implementation."
+#     id: ID!
+#   }
+#
+#   type User implements Node @node { id: ID! @globalId ... }
+#
+#   type Query {
+#     node(id: ID! @globalId): Node @field(resolver: "Lighthouse::GraphQL::NodeRegistry@resolve")
+#   }
+#
+# leaving alone what the SDL declares itself (a Node interface, a Query.node
+# field, with its own description or middleware). The type keeps its own
+# `id: ID! @globalId`, which encodes the ids `node` decodes. NodeRegistry finds
+# the record: through the type's `model:` or model, or its `resolver:`.
+class Lighthouse::GraphQL::Directives::NodeDirective
+  DEFINITIONS = {
+    'node' => <<~GRAPHQL.chomp
+      """
+      Register a type for Relay's global object identification.
+
+      When used without any arguments, Lighthouse will attempt
+      to resolve the type through a model with the same name.
+      """
+      directive @node(
+        """
+        Reference to a class (and method, after `@`) that receives the decoded `id`
+        and the context, and returns the object.
+
+        Mutually exclusive with `model`.
+        """
+        resolver: String
+
+        """
+        Specify the class name of the model to use.
+        This is only needed when the default model detection does not work.
+
+        Mutually exclusive with `resolver`.
+        """
+        model: String
+      ) on OBJECT
+    GRAPHQL
+  }.freeze
+
+  INTERFACE = <<~GRAPHQL.chomp
+    "Any object implementing this type can be found by ID through `Query.node`."
+    interface Node @interface(resolveType: "Lighthouse::GraphQL::NodeRegistry") {
+      "Global identifier that can be used to resolve any Node implementation."
+      id: ID!
+    }
+  GRAPHQL
+
+  NODE_FIELD = <<~GRAPHQL.chomp
+    type Query {
+      "Fetches an object given its globally unique `ID`."
+      node(id: ID! @globalId): Node @field(resolver: "Lighthouse::GraphQL::NodeRegistry@resolve")
+    }
+  GRAPHQL
+
+  OBJECTS = [::GraphQL::Language::Nodes::ObjectTypeDefinition, ::GraphQL::Language::Nodes::ObjectTypeExtension].freeze
+
+  DECLARATION = /directive\s+@node\b/
+  USAGE = /@node\b/
+
+  def self.manipulate(sdl)
+    return sdl unless sdl.is_a?(String) && sdl.gsub(DECLARATION, '').match?(USAGE)
+
+    new(::GraphQL::Language::Parser.parse(sdl)).manipulate(sdl)
+  rescue ::GraphQL::ParseError
+    sdl
+  end
+
+  def initialize(document)
+    @document = document
+  end
+
+  def manipulate(sdl)
+    return sdl unless @document.definitions.any? { |definition| node?(definition) }
+
+    definitions = @document.definitions.map { |definition| node?(definition) ? implement_node(definition) : definition }
+    definitions = with_node_field(definitions)
+    printed = ::GraphQL::Language::Printer.new.print(@document.merge(definitions: definitions))
+    printed = "#{printed}\n\n#{INTERFACE}" unless declared?('Node')
+    # The added @globalId, @field and @interface need their definitions too.
+    Lighthouse::GraphQL::SchemaGenerator.inject_directive_definitions(printed)
+  end
+
+  private
+
+  def node?(definition)
+    OBJECTS.any? { |kind| definition.is_a?(kind) } && definition.directives.any? { |directive| directive.name == 'node' }
+  end
+
+  def implement_node(definition)
+    return definition if definition.interfaces.any? { |interface| interface.name == 'Node' }
+
+    definition.merge(interfaces: definition.interfaces + [::GraphQL::Language::Nodes::TypeName.new(name: 'Node')])
+  end
+
+  # Query gains `node`, unless a Query definition or extension has one. With
+  # no Query at all, the schema gets one with `node` alone.
+  def with_node_field(definitions)
+    queries = definitions.select { |definition| query?(definition) }
+    return definitions if queries.any? { |query| node_field?(query) }
+
+    node_query = ::GraphQL::Language::Parser.parse(NODE_FIELD).definitions.first
+    return definitions + [node_query] if queries.empty?
+
+    definitions.map { |definition| definition.equal?(queries.first) ? definition.merge(fields: definition.fields + node_query.fields) : definition }
+  end
+
+  def node_field?(query)
+    query.fields.any? { |field| field.name == 'node' }
+  end
+
+  def query?(definition)
+    OBJECTS.any? { |kind| definition.is_a?(kind) } && definition.name == query_name
+  end
+
+  def query_name
+    schema = @document.definitions.find { |definition| definition.is_a?(::GraphQL::Language::Nodes::SchemaDefinition) }
+    schema&.query || 'Query'
+  end
+
+  def declared?(name)
+    @document.definitions.any? { |definition| definition.respond_to?(:name) && definition.name == name && !definition.is_a?(::GraphQL::Language::Nodes::ObjectTypeExtension) }
+  end
+end

data/lib/lighthouse/directives/pagination_manipulator.rb

@@ -16,7 +16,7 @@ require_relative 'pagination_info_types'
 # relation directive (no `type:`) and @all keep returning the list.
 # The runtime side is Lighthouse::GraphQL::Pagination.
 class Lighthouse::GraphQL::Directives::PaginationManipulator
-  RELATION_DIRECTIVES = %w[hasMany belongsToMany morphMany morphToMany].freeze
+  RELATION_DIRECTIVES = %w[hasMany hasManyThrough belongsToMany morphMany morphToMany].freeze
   OBJECT_DEFINITIONS = [
     ::GraphQL::Language::Nodes::ObjectTypeDefinition,
     ::GraphQL::Language::Nodes::ObjectTypeExtension