lighthouse-graphql 0.1.1 → 0.2.1

data/lib/lighthouse/directive_resolvers/all_resolver.rb

@@ -3,71 +3,40 @@
 require_relative 'base'
 require_relative 'builder_applier'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      class AllDirectiveResolver < BaseDirectiveResolver
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
+class Lighthouse::GraphQL::DirectiveResolvers::AllDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'all'
+  def self.definition = 'directive @all(model: String, scopes: [String!]) on FIELD_DEFINITION'
 
-          resolver_instance = self
-          field_ast_node = @field_def.ast_node
+  def define_resolver(target_type_class)
+    model_class = constantize_model(extract_model_name || @field_def.type.unwrap.graphql_name)
+    me = self
 
-          method_name = "resolve_field_#{field_name}"
-
-          model_name_static = extract_model_name || @field_def.type.unwrap.name
-          model_class_static = constantize_model(model_name_static)
-
-          target_type_class.define_singleton_method(method_name) do |_obj, arguments, ctx|
-            model_class = model_class_static
-            return [] unless model_class
-
-            # apply simple pagination args if present
-            args = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-            relation = model_class.all
-
-            relation = DirectiveResolvers::BuilderApplier.apply(relation, field_ast_node, args, ctx, resolver_instance)
+    install(target_type_class, lambda do |_obj, arguments, ctx|
+      me.send(:resolve_all, model_class, arguments, ctx)
+    end)
+  end
 
-            relation = resolver_instance.apply_where_filters(relation, args)
-            relation = relation.limit(args[:first]) if args[:first]
-            relation = relation.offset(args[:offset]) if args[:offset]
-            relation
-          end
+  private
 
-          if @field_def.respond_to?(:resolve_proc=)
-            @field_def.resolve_proc = ->(_obj, arguments, ctx) do
-              model_class = model_class_static
-              if model_class.nil?
-                []
-              else
-                args = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-                relation = model_class.all
+  def resolve_all(model_class, arguments, ctx)
+    return [] unless model_class
 
-                relation = DirectiveResolvers::BuilderApplier.apply(relation, field_ast_node, args, ctx, resolver_instance)
+    # apply simple pagination args if present
+    args = arguments.respond_to?(:to_h) ? arguments.to_h : {}
+    relation = apply_scopes(model_class.all)
 
-                relation = resolver_instance.apply_where_filters(relation, args)
-                relation = relation.limit(args[:first]) if args[:first]
-                relation = relation.offset(args[:offset]) if args[:offset]
-                relation
-              end
-            end
-          end
-        end
+    relation = Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply(relation, @field_def.ast_node, args, ctx, self)
 
-        private
+    relation = apply_where_filters(relation, args)
+    relation = relation.limit(args[:first]) if args[:first]
+    relation = relation.offset(args[:offset]) if args[:offset]
+    relation
+  end
 
-        def extract_model_name
-          arg = @directive_node.arguments&.find { |a| a.name == 'model' }
-          return nil unless arg
-          arg.value.respond_to?(:value) ? arg.value.value : arg.value
-        end
+  def extract_model_name
+    arg = @directive_node.arguments&.find { |a| a.name == 'model' }
+    return nil unless arg
 
-        def constantize_model(name)
-          return nil unless name
-          name = name.to_s.split('::').last
-          Object.const_get(name) rescue nil
-        end
-      end
-    end
+    arg.value.respond_to?(:value) ? arg.value.value : arg.value
   end
 end

data/lib/lighthouse/directive_resolvers/association_resolvers.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Lighthouse::GraphQL::DirectiveResolvers
+  # Relationship directives: resolve an ActiveRecord association of the
+  # parent. `relation:` names it (default: the field name in snake_case);
+  # `scopes:` applies model scopes. The Morph* directives are PHP Lighthouse's
+  # names for polymorphic associations, which ActiveRecord resolves the same way.
+  #
+  # Without query constraints the association is batch-loaded through the
+  # Dataloader (one query per association per batch). Collection directives
+  # take PHP Lighthouse's `type:` — PAGINATOR, SIMPLE or CONNECTION — to
+  # paginate (see Directives::PaginationManipulator), and the field's argument
+  # filters (@eq, @where, @orderBy, ...) apply to the association's query.
+  # Pages are batched too: every parent's page in one query, and the totals
+  # in another (see RelationBatch).
+  class AssociationDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+    CONDITION_DIRECTIVES = %w[whereConditions whereHasConditions].freeze
+
+    def self.collection? = false
+
+    def define_resolver(target_type_class)
+      me = self
+      install(target_type_class, lambda do |obj, args, ctx|
+        next nil if obj.nil?
+
+        me.send(:resolve_association, obj, Lighthouse::Support::Arguments.shallow(args), ctx)
+      end)
+    end
+
+    protected
+
+    def resolve_association(obj, args, ctx)
+      name = association_name
+      return nil unless obj.respond_to?(name)
+
+      return paginate(obj, name, args, ctx) if pagination_type
+      return constrained(association_scope(obj, name), args) if constrained?(args)
+
+      dataloader = Lighthouse::Support::Batching.dataloader(ctx)
+      return obj.public_send(name) unless dataloader && obj.class.respond_to?(:reflect_on_association)
+
+      dataloader.with(Lighthouse::GraphQL::DataloaderSources::AssociationLoader, obj.class, name).load(obj)
+    end
+
+    def association_name
+      (directive_arg('relation') || Lighthouse::Support::Naming.attribute(@field_def.name)).to_s
+    end
+
+    def pagination_type
+      self.class.collection? && directive_arg('type')&.to_s&.upcase
+    end
+
+    # Scopes or a supplied argument with a filter directive need a query of
+    # their own instead of the batched load.
+    def constrained?(args)
+      return true if directive_arg('scopes')
+
+      registry = Lighthouse::DirectiveRegistry.default
+      (@field_def.ast_node&.arguments || []).any? do |argument|
+        args.key?(argument.name.underscore.to_sym) && argument.directives.any? { |d| filter_directive?(registry, d) }
+      end
+    end
+
+    # An argument builder (@eq, @where, ...) or a where-conditions filter.
+    def filter_directive?(registry, directive)
+      registry.arg_builder_class(directive.name) || CONDITION_DIRECTIVES.include?(directive.name)
+    end
+
+    def constrained(relation, args)
+      relation = apply_where_filters(scoped(relation), args)
+      self.class.collection? ? relation : relation.first
+    end
+
+    def paginate(obj, name, args, ctx)
+      limits = { default_count: directive_arg('defaultCount') }
+      limits[:max_count] = directive_arg('maxCount') || :unlimited if directive_given?('maxCount')
+      Lighthouse::GraphQL::Pagination.paginate(paginated_list(obj, name, args, ctx), pagination_type, args, limits)
+    end
+
+    # This parent's page, batched with its siblings' when the Dataloader can.
+    def paginated_list(obj, name, args, ctx)
+      dataloader = Lighthouse::Support::Batching.dataloader(ctx)
+      batch = dataloader && Lighthouse::GraphQL::RelationBatch.for(obj, name, args, self, ctx)
+      return Lighthouse::GraphQL::Pagination::BatchedList.new(batch, obj, dataloader) if batch
+
+      decorate_relation(association_scope(obj, name), args, ctx)
+    end
+
+    public
+
+    # The field's scopes and filters on the association's query, for one
+    # parent or a RelationBatch of them.
+    def decorate_relation(relation, args, _ctx)
+      apply_where_filters(scoped(relation), args)
+    end
+
+    protected
+
+    # The association as a query (for a singular association too), so scopes
+    # and filters can be applied to it.
+    def association_scope(obj, name)
+      obj.respond_to?(:association) ? obj.association(name.to_sym).scope : obj.public_send(name)
+    end
+
+    def scoped(relation)
+      Array(directive_arg('scopes')).reduce(relation) { |acc, scope| acc.public_send(scope) }
+    end
+
+    def directive_given?(name)
+      @directive_node&.arguments&.any? { |a| a.name == name }
+    end
+  end
+
+  COLLECTION_ARGUMENTS = 'relation: String, scopes: [String!], type: PaginateType, defaultCount: Int, maxCount: Int'
+
+  class HasManyDirectiveResolver < AssociationDirectiveResolver
+    def self.collection? = true
+    def self.directive_name = 'hasMany'
+    def self.definition = "directive @hasMany(#{COLLECTION_ARGUMENTS}) on FIELD_DEFINITION"
+  end
+
+  class BelongsToManyDirectiveResolver < AssociationDirectiveResolver
+    def self.collection? = true
+    def self.directive_name = 'belongsToMany'
+    def self.definition = "directive @belongsToMany(#{COLLECTION_ARGUMENTS}) on FIELD_DEFINITION"
+  end
+
+  class MorphManyDirectiveResolver < AssociationDirectiveResolver
+    def self.collection? = true
+    def self.directive_name = 'morphMany'
+    def self.definition = "directive @morphMany(#{COLLECTION_ARGUMENTS}) on FIELD_DEFINITION"
+  end
+
+  class MorphToManyDirectiveResolver < AssociationDirectiveResolver
+    def self.collection? = true
+    def self.directive_name = 'morphToMany'
+    def self.definition = "directive @morphToMany(#{COLLECTION_ARGUMENTS}) on FIELD_DEFINITION"
+  end
+
+  class HasOneDirectiveResolver < AssociationDirectiveResolver
+    def self.directive_name = 'hasOne'
+    def self.definition = 'directive @hasOne(relation: String, scopes: [String!]) on FIELD_DEFINITION'
+  end
+
+  class MorphOneDirectiveResolver < AssociationDirectiveResolver
+    def self.directive_name = 'morphOne'
+    def self.definition = 'directive @morphOne(relation: String, scopes: [String!]) on FIELD_DEFINITION'
+  end
+
+  class BelongsToDirectiveResolver < AssociationDirectiveResolver
+    def self.directive_name = 'belongsTo'
+    def self.definition = 'directive @belongsTo(relation: String, scopes: [String!]) on FIELD_DEFINITION'
+  end
+
+  class MorphToDirectiveResolver < AssociationDirectiveResolver
+    def self.directive_name = 'morphTo'
+    def self.definition = 'directive @morphTo(relation: String, scopes: [String!]) on FIELD_DEFINITION'
+  end
+end

data/lib/lighthouse/directive_resolvers/auth_resolver.rb

@@ -1,44 +1,47 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      class AuthDirectiveResolver < BaseDirectiveResolver
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
-          method_name = "resolve_field_#{field_name}"
-
-          original_singleton =
-            if target_type_class.respond_to?(method_name)
-              target_type_class.method(method_name)
-            end
-
-          original_proc =
-            if @field_def.respond_to?(:resolve_proc)
-              @field_def.resolve_proc
-            end
-
-          wrapper = lambda do |obj, arguments, ctx|
-            user = ctx && (ctx[:current_user] || ctx['current_user'])
-            raise(::GraphQL::ExecutionError, 'Unauthenticated.') unless user
-
-            if original_singleton
-              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 = field_name.to_s.underscore
-              obj.respond_to?(snake) ? obj.public_send(snake) : nil
-            end
-          end
-
-          target_type_class.define_singleton_method(method_name, &wrapper)
-          @field_def.resolve_proc = wrapper if @field_def.respond_to?(:resolve_proc=)
-        end
+class Lighthouse::GraphQL::DirectiveResolvers::AuthDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'auth'
+  def self.definition = 'directive @auth on FIELD_DEFINITION'
+
+  def define_resolver(target_type_class)
+    inner = original_resolver(target_type_class)
+
+    install(target_type_class, lambda do |obj, arguments, ctx|
+      user = ctx && (ctx[:current_user] || ctx['current_user'])
+      raise(::GraphQL::ExecutionError, 'Unauthenticated.') unless user
+
+      inner.call(obj, arguments, ctx)
+    end)
+  end
+
+  private
+
+  # The field's resolver so far: an existing `resolve_field_*` method, the
+  # resolve_proc, or the parent's attribute reader.
+  def original_resolver(target_type_class)
+    field_name = @field_def.name
+    original_singleton =
+      (target_type_class.method(resolver_method_name) if target_type_class.respond_to?(resolver_method_name))
+
+    original_proc =
+      (@field_def.resolve_proc if @field_def.respond_to?(:resolve_proc))
+
+    lambda do |obj, arguments, ctx|
+      if original_singleton
+        original_singleton.call(obj, arguments, ctx)
+      elsif original_proc
+        original_proc.call(obj, arguments, ctx)
+      else
+        read_attribute(obj, field_name)
       end
     end
   end
-end
 
+  def read_attribute(obj, field_name)
+    return obj.public_send(field_name) if obj.respond_to?(field_name)
+
+    snake = field_name.to_s.underscore
+    obj.respond_to?(snake) ? obj.public_send(snake) : nil
+  end
+end

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