lighthouse-graphql 0.1.1 → 0.2.0

data/lib/lighthouse/directive_resolvers/base.rb

@@ -1,91 +1,147 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      class BaseDirectiveResolver
-        def initialize(field_def, type_def, directive_node, opts = {})
-          @field_def = field_def
-          @type_def = type_def
-          @directive_node = directive_node
-          @opts = opts
-        end
-
-        def define_resolver(target_type_class)
-          raise NotImplementedError
-        end
-
-        def apply_where_filters(relation, args)
-          return relation unless relation.respond_to?(:where)
-
-          args_h = args.respond_to?(:to_h) ? args.to_h : (args || {})
-
-          where_condition = args_h[:where] || args_h['where']
-          relation = DirectiveResolvers::WhereConditionsApplier.apply(relation, where_condition) if where_condition
-
-          @field_def.ast_node.arguments.each do |arg_node|
-            next unless arg_node.directives.any? { |dir| dir.name == 'whereHasConditions' }
-
-            arg_value = Lighthouse::Support::Naming.fetch_arg(args_h, arg_node.name)
-            next unless arg_value
-
-            relation_name = extract_relation_name_from_directive(arg_node) || Lighthouse::Support::Naming.derive_relation_name(arg_node.name)
-            relation = DirectiveResolvers::WhereConditionsApplier.apply_has_argument(relation, arg_node.name, arg_value, relation_name)
-          end
-
-          apply_arg_builders(relation, args_h)
-        rescue ::GraphQL::ExecutionError
-          raise
-        rescue StandardError => e
-          Lighthouse::Config.handle_error(e)
-          relation
-        end
-
-        # Compose argument-builder directives (@eq, @neq, @in, @notIn, @like,
-        # @where, @orderBy) onto the relation, in SDL argument order, for each
-        # field argument that carries one and that the client supplied a value
-        # for.
-        def apply_arg_builders(relation, args_h)
-          return relation unless relation.respond_to?(:where)
-          return relation unless @field_def.ast_node
-
-          registry = Lighthouse::DirectiveRegistry.default
-
-          (@field_def.ast_node.arguments || []).each do |arg_node|
-            (arg_node.directives || []).each do |dnode|
-              builder_class = registry.arg_builder_class(dnode.name)
-              next unless builder_class
-
-              value = Lighthouse::Support::Naming.fetch_arg(args_h, arg_node.name)
-              next if value.nil?
-
-              relation = builder_class.new(arg_node, dnode).handle_builder(relation, value)
-            end
-          end
-
-          relation
-        rescue ::GraphQL::ExecutionError
-          raise
-        rescue StandardError => e
-          Lighthouse::Config.handle_error(e)
-          relation
-        end
-
-        def extract_relation_name_from_directive(arg_node)
-          directive = arg_node.directives.find { |dir| dir.name == 'whereHasConditions' }
-          return nil unless directive
-
-          relation_arg = directive.arguments.find { |arg| arg.name == 'relation' }
-          return nil unless relation_arg
-
-          relation_arg.value.respond_to?(:value) ? relation_arg.value.value : relation_arg.value
-        rescue StandardError
-          nil
-        end
-
-        def constantize_model(name)
-          Lighthouse::Support::ModelResolver.constantize(name)
-        end
+class Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def initialize(field_def, type_def, directive_node, opts = {})
+    @field_def = field_def
+    @type_def = type_def
+    @directive_node = directive_node
+    @opts = opts
+  end
+
+  def define_resolver(target_type_class)
+    raise NotImplementedError
+  end
+
+  def apply_where_filters(relation, args)
+    return relation unless relation.respond_to?(:where)
+
+    args_h = args.respond_to?(:to_h) ? args.to_h : (args || {})
+
+    relation = apply_where_conditions(relation, args_h)
+    @field_def.ast_node.arguments.each do |arg_node|
+      relation = apply_where_has_conditions(relation, arg_node, args_h)
+    end
+
+    apply_arg_builders(relation, args_h)
+  rescue ::GraphQL::ExecutionError
+    raise
+  rescue StandardError => e
+    Lighthouse::Config.handle_error(e)
+    relation
+  end
+
+  # Compose argument-builder directives (@eq, @neq, @in, @notIn, @like,
+  # @where, @orderBy) onto the relation, in SDL argument order, for each
+  # field argument that carries one and that the client supplied a value
+  # for.
+  def apply_arg_builders(relation, args_h)
+    return relation unless relation.respond_to?(:where)
+    return relation unless @field_def.ast_node
+
+    arg_builders.each do |arg_node, dnode, builder_class|
+      value = Lighthouse::Support::Naming.fetch_arg(args_h, arg_node.name)
+      next if value.nil?
+
+      relation = builder_class.new(arg_node, dnode).handle_builder(relation, value)
+    end
+
+    relation
+  rescue ::GraphQL::ExecutionError
+    raise
+  rescue StandardError => e
+    Lighthouse::Config.handle_error(e)
+    relation
+  end
+
+  def extract_relation_name_from_directive(arg_node)
+    directive = arg_node.directives.find { |dir| dir.name == 'whereHasConditions' }
+    return nil unless directive
+
+    relation_arg = directive.arguments.find { |arg| arg.name == 'relation' }
+    return nil unless relation_arg
+
+    relation_arg.value.respond_to?(:value) ? relation_arg.value.value : relation_arg.value
+  rescue StandardError
+    nil
+  end
+
+  def constantize_model(name)
+    Lighthouse::Support::ModelResolver.constantize(name)
+  end
+
+  # The model scopes the directive's `scopes:` argument names, in order.
+  def apply_scopes(relation)
+    Array(directive_arg('scopes')).reduce(relation) { |acc, scope| acc.public_send(scope) }
+  end
+
+  protected
+
+  def directive_arg(name)
+    Lighthouse::Support::DirectiveArgs.literal(@directive_node, name)
+  end
+
+  def resolver_method_name
+    "resolve_field_#{@field_def.name}"
+  end
+
+  # The field's resolver so far, for a directive that wraps it.
+  def capture_inner(target_type_class)
+    Lighthouse::GraphQL::DirectiveResolvers::Resolution.capture(target_type_class, resolver_method_name, @field_def, @field_def.name)
+  end
+
+  def install(target_type_class, callable)
+    target_type_class.define_singleton_method(resolver_method_name, &callable)
+    @field_def.resolve_proc = callable if @field_def.respond_to?(:resolve_proc=)
+  end
+
+  # The model a directive acts on: its `model:` argument, the `model:` of
+  # another directive on the field (`@count(model: "Post") @canQuery`), or
+  # the field's return type without a generated Paginator/Connection suffix.
+  def model_class
+    name = directive_arg('model') || sibling_model_name || return_type_model_name
+    constantize_model(name) || raise(Lighthouse::DefinitionError,
+                                     "@#{@directive_node&.name} on #{@type_def.graphql_name}.#{@field_def.name}: no model #{name}")
+  end
+
+  private
+
+  def sibling_model_name
+    (@field_def.ast_node&.directives || []).filter_map do |d|
+      Lighthouse::Support::DirectiveArgs.literal(d, 'model')
+    end.first
+  end
+
+  def return_type_model_name
+    @field_def.type.unwrap.graphql_name.sub(/(SimplePaginator|Paginator|Connection)\z/, '')
+  end
+
+  # The `where:` argument (@whereConditions), when the client supplied one.
+  def apply_where_conditions(relation, args_h)
+    where_condition = args_h[:where] || args_h['where']
+    return relation unless where_condition
+
+    Lighthouse::GraphQL::DirectiveResolvers::WhereConditionsApplier.apply(relation, where_condition)
+  end
+
+  # A `whereHasConditions` argument the client supplied filters the
+  # relation by the related records matching its condition.
+  def apply_where_has_conditions(relation, arg_node, args_h)
+    return relation unless arg_node.directives.any? { |dir| dir.name == 'whereHasConditions' }
+
+    arg_value = Lighthouse::Support::Naming.fetch_arg(args_h, arg_node.name)
+    return relation unless arg_value
+
+    relation_name = extract_relation_name_from_directive(arg_node) || Lighthouse::Support::Naming.derive_relation_name(arg_node.name)
+    Lighthouse::GraphQL::DirectiveResolvers::WhereConditionsApplier.apply_has_argument(relation, arg_node.name, arg_value, relation_name)
+  end
+
+  # Every (argument, directive, builder class) on the field, in SDL order.
+  def arg_builders
+    registry = Lighthouse::DirectiveRegistry.default
+    (@field_def.ast_node.arguments || []).flat_map do |arg_node|
+      (arg_node.directives || []).filter_map do |dnode|
+        builder_class = registry.arg_builder_class(dnode.name)
+        [arg_node, dnode, builder_class] if builder_class
       end
     end
   end

data/lib/lighthouse/directive_resolvers/builder_applier.rb

@@ -2,62 +2,64 @@
 
 require_relative 'base'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      class BuilderApplier
-        def self.apply(relation, field_def_ast_node, args, ctx, resolver_instance)
-          return relation unless field_def_ast_node && field_def_ast_node.directives
-
-          builder_directives = field_def_ast_node.directives.select { |d| d.name == 'builder' }
-          return relation if builder_directives.empty?
-
-          builder_directives.each do |directive_node|
-            relation = apply_directive(relation, directive_node, args, ctx, resolver_instance)
-          end
-
-          relation
-        end
-
-        def self.apply_directive(relation, directive_node, args, ctx, resolver_instance)
-          class_name = extract_directive_arg(directive_node, 'class')
-          method_name = extract_directive_arg(directive_node, 'method') || 'call'
-
-          return relation unless class_name
-
-          builder_class = resolver_instance.send(:constantize_model, class_name)
-          return relation unless builder_class
-
-          if builder_class.respond_to?(method_name)
-            result = builder_class.public_send(method_name, relation, args, ctx)
-            result || relation
-          elsif builder_class.is_a?(Class)
-            instance = builder_class.new
-            if instance.respond_to?(method_name)
-              result = instance.public_send(method_name, relation, args, ctx)
-              result || relation
-            else
-              relation
-            end
-          else
-            relation
-          end
-        rescue ::GraphQL::ExecutionError
-          # Client-facing errors (e.g. authorization / scoping guards raised by a
-          # builder) MUST propagate — never silently fall back to the unscoped
-          # relation, or a builder that enforces tenancy could be bypassed.
-          raise
-        rescue StandardError => e
-          Lighthouse::Config.handle_error(e)
-          relation
-        end
-
-        def self.extract_directive_arg(directive_node, name)
-          arg = directive_node.arguments&.find { |a| a.name == name }
-          return nil unless arg
-          arg.value.respond_to?(:value) ? arg.value.value : arg.value
-        end
-      end
+class Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier
+  DEFINITION = 'directive @builder(class: String!, method: String) repeatable on FIELD_DEFINITION'
+
+  def self.apply(relation, field_def_ast_node, args, ctx, resolver_instance)
+    return relation unless field_def_ast_node&.directives
+
+    builder_directives = field_def_ast_node.directives.select { |d| d.name == 'builder' }
+    return relation if builder_directives.empty?
+
+    builder_directives.each do |directive_node|
+      relation = apply_directive(relation, directive_node, args, ctx, resolver_instance)
     end
+
+    relation
+  end
+
+  def self.apply_directive(relation, directive_node, args, ctx, _resolver_instance)
+    class_name = extract_directive_arg(directive_node, 'class')
+    method_name = extract_directive_arg(directive_node, 'method') || 'call'
+
+    return relation unless class_name
+
+    # Builders are not resolvers: they compose onto a relation, and live in
+    # their own namespace (Config.namespaces[:builders], app/graphql/builders).
+    builder_class = Lighthouse::Support::ModelResolver.constantize(
+      class_name, namespaces: Lighthouse::Config.namespaces[:builders]
+    )
+    return relation unless builder_class
+
+    receiver = builder_receiver(builder_class, method_name)
+    return relation unless receiver
+
+    receiver.public_send(method_name, relation, args, ctx) || relation
+  rescue ::GraphQL::ExecutionError
+    # Client-facing errors (e.g. authorization / scoping guards raised by a
+    # builder) MUST propagate — never silently fall back to the unscoped
+    # relation, or a builder that enforces tenancy could be bypassed.
+    raise
+  rescue StandardError => e
+    Lighthouse::Config.handle_error(e)
+    relation
+  end
+
+  def self.extract_directive_arg(directive_node, name)
+    arg = directive_node.arguments&.find { |a| a.name == name }
+    return nil unless arg
+
+    arg.value.respond_to?(:value) ? arg.value.value : arg.value
+  end
+
+  # What answers the builder method: the class itself, else an instance
+  # of it; nil when neither does.
+  def self.builder_receiver(builder_class, method_name)
+    return builder_class if builder_class.respond_to?(method_name)
+    return nil unless builder_class.is_a?(Class)
+
+    instance = builder_class.new
+    instance if instance.respond_to?(method_name)
   end
+  private_class_method :builder_receiver
 end

data/lib/lighthouse/directive_resolvers/cache_resolvers.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Lighthouse::GraphQL::DirectiveResolvers
+  # @cache — keep a field's resolved value in Config.cache_store (Rails.cache).
+  #
+  # The key covers the parent type and its key (the field marked @cacheKey,
+  # else the first `ID` field; none on Query/Mutation), the field, and its
+  # arguments; `private: true` adds the authenticated user, so each user gets
+  # their own entry (guests share one). `maxAge` is in seconds; without it
+  # entries live until @clearCache or eviction. Lists and relations are
+  # cached as arrays; a value the store cannot serialize (e.g. a connection)
+  # is reported through Config.on_error and returned uncached.
+  class CacheDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+    def self.directive_name = 'cache'
+    def self.definition = 'directive @cache(maxAge: Int, private: Boolean = false) on FIELD_DEFINITION'
+
+    ROOT_TYPES = %w[Query Mutation Subscription].freeze
+
+    def define_resolver(target_type_class)
+      type_name = @type_def.graphql_name
+      field_name = @field_def.name
+      max_age = directive_arg('maxAge')
+      per_user = directive_arg('private') == true
+      parent_key = parent_key_reader
+      inner = capture_inner(target_type_class)
+
+      install(target_type_class, lambda do |obj, args, ctx|
+        user_key = per_user ? CacheDirectiveResolver.user_key(ctx) : nil
+        key = Lighthouse::GraphQL::Caching.entry_key(type_name, parent_key&.call(obj), field_name, args, user_key)
+        cached = Lighthouse::GraphQL::Caching.store.read(key)
+        next cached[:value] if cached.is_a?(Hash) && cached.key?(:value)
+
+        value = CacheDirectiveResolver.materialize(inner.call(obj, args, ctx))
+        CacheDirectiveResolver.write(key, value, max_age, ctx)
+        value
+      end)
+    end
+
+    def self.user_key(ctx)
+      user = Lighthouse::Support::Authorization.authenticated_user(ctx)
+      return nil if user.nil?
+
+      "user:#{user.respond_to?(:id) ? user.id : user}"
+    end
+
+    def self.materialize(value)
+      Lighthouse::Support::Arguments.list(value) || value
+    end
+
+    def self.write(key, value, max_age, ctx)
+      Lighthouse::GraphQL::Caching.store.write(key, { value: value }, expires_in: max_age)
+    rescue TypeError, ArgumentError, NoMethodError => e
+      Lighthouse::Config.handle_error(e, ctx)
+    end
+
+    private
+
+    # A callable reading the parent's cache key, or nil on root types.
+    def parent_key_reader
+      return nil if ROOT_TYPES.include?(@type_def.graphql_name)
+
+      key_field = cache_key_field
+      return nil unless key_field
+
+      name = key_field.name
+      ->(obj) { obj.nil? ? nil : Lighthouse::Support::Arguments.read(obj, name) }
+    end
+
+    # The field marked @cacheKey, else the first `ID` field.
+    def cache_key_field
+      fields = @type_def.fields.values
+      fields.find { |f| cache_key?(f) } || fields.find { |f| f.type.unwrap.graphql_name == 'ID' }
+    end
+
+    def cache_key?(field)
+      field.ast_node&.directives&.any? { |d| d.name == 'cacheKey' }
+    end
+  end
+
+  # @clearCache — on a mutation, invalidate @cache entries once the field
+  # resolved successfully. `type` alone clears all of that type's entries;
+  # `idSource` narrows it to the ids found at an argument path
+  # (`{ argument: "input.id" }`) or a result path (`{ field: "*.id" }`), and
+  # `field` to a single field.
+  class ClearCacheDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+    def self.directive_name = 'clearCache'
+
+    def self.definition
+      'directive @clearCache(type: String!, idSource: ClearCacheIdSource, field: String) ' \
+        'repeatable on FIELD_DEFINITION'
+    end
+
+    def self.type_definitions
+      {
+        'ClearCacheIdSource' => <<~GRAPHQL.chomp
+          "Where @clearCache finds the ids to clear. Exactly one of the fields must be given."
+          input ClearCacheIdSource {
+            "Path of an argument the field is applied to, e.g. \\"input.id\\"."
+            argument: String
+            "Path of a field in the result, e.g. \\"*.id\\" for a list."
+            field: String
+          }
+        GRAPHQL
+      }
+    end
+
+    def define_resolver(target_type_class)
+      type = directive_arg('type')
+      field = directive_arg('field')
+      source = directive_arg('idSource') || {}
+      inner = capture_inner(target_type_class)
+
+      install(target_type_class, lambda do |obj, args, ctx|
+        result = inner.call(obj, args, ctx)
+        ids =
+          if source['argument']
+            Lighthouse::Support::Arguments.dig(Lighthouse::Support::Arguments.plain(args), source['argument'])
+          elsif source['field']
+            Lighthouse::Support::Arguments.dig(result, source['field'])
+          end
+
+        if ids.nil?
+          Lighthouse::GraphQL::Caching.clear(type, field: field)
+        else
+          ids.flatten.uniq.each { |id| Lighthouse::GraphQL::Caching.clear(type, id: id, field: field) }
+        end
+        result
+      end)
+    end
+  end
+end

data/lib/lighthouse/directive_resolvers/can_resolvers.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Lighthouse::GraphQL::DirectiveResolvers
+  # The @can* family — PHP Lighthouse's authorization directives, checked
+  # with Pundit by default (Config.authorizer): `ability: "update"` calls
+  # `PostPolicy#update?`. Each directive differs only in WHAT it authorizes:
+  #
+  #   @canFind      the models whose primary keys an argument holds
+  #   @canModel     the model class (e.g. create? before a @create)
+  #   @canQuery     the models the field's query would return
+  #   @canResolved  whatever the field resolved to (each item of a list)
+  #   @canRoot      the parent object
+  #
+  # Shared arguments: `injectArgs` passes the field's arguments to the policy
+  # method, `args` passes static values after them, and `action` decides what
+  # a denial (or a @canFind miss) does — pass the error, replace it with a
+  # generic "This action is unauthorized.", or return `returnValue` instead.
+  # All are repeatable; they run after @guard and before validation.
+  class CanDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+    COMMON_ARGUMENTS = 'ability: String!, injectArgs: Boolean = false, args: CanArgs, ' \
+                       'action: CanAction = EXCEPTION_PASS, returnValue: CanArgs'
+
+    TYPE_DEFINITIONS = {
+      'CanArgs' => '"Any constant literal value: https://graphql.github.io/graphql-spec/draft/#sec-Input-Values"' \
+                   "\nscalar CanArgs",
+      'CanAction' => <<~GRAPHQL.chomp
+        "What a @can* directive does when the policy denies the ability."
+        enum CanAction {
+          "Pass the error to the client."
+          EXCEPTION_PASS
+          "Throw a generic \\"This action is unauthorized.\\" error, concealing the real one."
+          EXCEPTION_NOT_AUTHORIZED
+          "Return the value of returnValue instead of resolving the field."
+          RETURN_VALUE
+        }
+      GRAPHQL
+    }.freeze
+
+    def self.type_definitions = TYPE_DEFINITIONS
+
+    def self.definition_with(extra = nil)
+      "directive @#{directive_name}(#{[COMMON_ARGUMENTS, extra].compact.join(', ')}) repeatable on FIELD_DEFINITION"
+    end
+
+    def define_resolver(target_type_class)
+      me = self
+      inner = capture_inner(target_type_class)
+      install(target_type_class, lambda do |obj, args, ctx|
+        catch(me) { me.send(:authorize_and_resolve, inner, obj, args, ctx) }
+      end)
+    end
+
+    protected
+
+    def authorize_and_resolve(inner, obj, args, ctx)
+      check { authorize_before(obj, args, ctx) }
+      inner.call(obj, args, ctx)
+    end
+
+    def authorize_before(_obj, _args, _ctx)
+      raise NotImplementedError
+    end
+
+    # Run an authorization step, turning its failure into what `action:` asks for.
+    def check
+      yield
+    rescue ::GraphQL::ExecutionError
+      case directive_arg('action')
+      when 'EXCEPTION_NOT_AUTHORIZED' then raise Lighthouse::AuthorizationError
+      when 'RETURN_VALUE' then throw(self, directive_arg('returnValue'))
+      else raise
+      end
+    end
+
+    def authorize!(ctx, record, args)
+      ability = directive_arg('ability')
+      return if Lighthouse::Support::Authorization.authorized?(ctx, record, ability, policy_args(args))
+
+      raise Lighthouse::AuthorizationError
+    end
+
+    def authorize_each!(ctx, records, args)
+      records.each { |record| authorize!(ctx, record, args) }
+    end
+
+    def policy_args(args)
+      values = []
+      values << Lighthouse::Support::Arguments.plain(args) if directive_arg('injectArgs')
+      static = directive_arg('args')
+      values.concat(static.is_a?(Array) ? static : [static]) unless static.nil?
+      values
+    end
+
+    def scoped(relation)
+      Array(directive_arg('scopes')).reduce(relation) { |acc, scope| acc.public_send(scope) }
+    end
+  end
+
+  class CanFindDirectiveResolver < CanDirectiveResolver
+    def self.directive_name = 'canFind'
+    def self.definition = definition_with('find: String!, model: String, findOrFail: Boolean = true, scopes: [String!]')
+
+    protected
+
+    def authorize_before(_obj, args, ctx)
+      model = model_class
+      ids = Lighthouse::Support::Arguments.dig(Lighthouse::Support::Arguments.plain(args), directive_arg('find')).flatten.uniq
+      records = scoped(model.where(model.primary_key => ids)).to_a
+      if directive_arg('findOrFail') != false && records.size < ids.size
+        missing = ids.map(&:to_s) - records.map { |r| r.public_send(model.primary_key).to_s }
+        raise ::GraphQL::ExecutionError, "Couldn't find #{model.name} with '#{model.primary_key}'=#{missing.join(', ')}"
+      end
+
+      authorize_each!(ctx, records, args)
+    end
+  end
+
+  class CanModelDirectiveResolver < CanDirectiveResolver
+    def self.directive_name = 'canModel'
+    def self.definition = definition_with('model: String')
+
+    protected
+
+    def authorize_before(_obj, args, ctx)
+      authorize!(ctx, model_class, args)
+    end
+  end
+
+  class CanQueryDirectiveResolver < CanDirectiveResolver
+    def self.directive_name = 'canQuery'
+    def self.definition = definition_with('model: String, scopes: [String!]')
+
+    protected
+
+    # The records the field's argument filters (@eq, @where, ...) select.
+    def authorize_before(_obj, args, ctx)
+      authorize_each!(ctx, apply_where_filters(scoped(model_class.all), args).to_a, args)
+    end
+  end
+
+  class CanResolvedDirectiveResolver < CanDirectiveResolver
+    def self.directive_name = 'canResolved'
+    def self.definition = definition_with
+
+    protected
+
+    # The resolver runs first: only use it on fields that do not mutate data.
+    def authorize_and_resolve(inner, obj, args, ctx)
+      result = inner.call(obj, args, ctx)
+      check { authorize_each!(ctx, resolved_records(result), args) }
+      result
+    end
+
+    def resolved_records(result)
+      case result
+      when nil then []
+      when Lighthouse::GraphQL::Pagination::Paginator then result.data
+      when Lighthouse::GraphQL::Pagination::Connection then result.edges.pluck('node')
+      when Hash then result.key?('data') ? Array(result['data']) : [result] # a simple paginator, or a record as a Hash
+      else Lighthouse::Support::Arguments.list(result) || [result]
+      end
+    end
+  end
+
+  class CanRootDirectiveResolver < CanDirectiveResolver
+    def self.directive_name = 'canRoot'
+    def self.definition = definition_with
+
+    protected
+
+    def authorize_before(obj, args, ctx)
+      authorize!(ctx, obj, args)
+    end
+  end
+end