lighthouse-graphql 0.1.0 → 0.2.0

data/lib/lighthouse/dataloader_sources/model_loader.rb

@@ -1,19 +1,15 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  module GraphQL
-    module DataloaderSources
-      class ModelLoader < ::GraphQL::Dataloader::Source
-        def initialize(model_class)
-          @model_class = model_class
-        end
+class Lighthouse::GraphQL::DataloaderSources::ModelLoader < GraphQL::Dataloader::Source
+  def initialize(model_class)
+    super()
+    @model_class = model_class
+  end
 
-        # keys are ids
-        def fetch(keys)
-          records = @model_class.where(id: keys).index_by(&:id)
-          keys.map { |k| records[k] }
-        end
-      end
-    end
+  # Keys are ids. GraphQL `ID` arguments arrive as strings while records
+  # carry their column type (usually Integer), so match on the string form.
+  def fetch(keys)
+    records = @model_class.where(id: keys).index_by { |record| record.id.to_s }
+    keys.map { |k| records[k.to_s] }
   end
 end

data/lib/lighthouse/dataloader_sources/relation_count_loader.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# The total of a paginated relation for every parent the Dataloader collected,
+# in one GROUP BY query. Only asked for when the client selects a total.
+class Lighthouse::GraphQL::DataloaderSources::RelationCountLoader < GraphQL::Dataloader::Source
+  def initialize(batch)
+    super()
+    @batch = batch
+  end
+
+  # keys: the parent records
+  def fetch(owners)
+    counts = @batch.counts(owners)
+    owners.map { |owner| counts.fetch(@batch.owner_key(owner), 0) }
+  end
+end

data/lib/lighthouse/dataloader_sources/relation_page_loader.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# One page of a paginated relation for every parent the Dataloader collected,
+# in one query (see Lighthouse::GraphQL::RelationBatch).
+class Lighthouse::GraphQL::DataloaderSources::RelationPageLoader < GraphQL::Dataloader::Source
+  def initialize(batch, offset, limit)
+    super()
+    @batch = batch
+    @offset = offset
+    @limit = limit
+  end
+
+  # keys: the parent records
+  def fetch(owners)
+    pages = @batch.pages(owners, @offset, @limit)
+    owners.map { |owner| pages.fetch(@batch.owner_key(owner), []) }
+  end
+end

data/lib/lighthouse/directive_resolvers/aggregate_resolver.rb

@@ -3,84 +3,72 @@
 require_relative 'base'
 require_relative 'builder_applier'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      class AggregateDirectiveResolver < BaseDirectiveResolver
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
-          method_name = "resolve_field_#{field_name}"
+class Lighthouse::GraphQL::DirectiveResolvers::AggregateDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'aggregate'
 
-          model_name = extract_directive_arg('model')
-          relation_name = extract_directive_arg('relation')
-          column_name = extract_directive_arg('column')
-          function_name = extract_directive_arg('function')
-          resolver_instance = self
-          field_ast_node = @field_def.ast_node
+  # An unknown function aggregates to null.
+  AGGREGATIONS = {
+    'SUM' => ->(relation, column) { relation.sum(column) },
+    'AVG' => ->(relation, column) { relation.average(column)&.to_f },
+    'MIN' => ->(relation, column) { relation.minimum(column) },
+    'MAX' => ->(relation, column) { relation.maximum(column) },
+    'COUNT' => ->(relation, _column) { relation.count }
+  }.freeze
 
-          resolver_lambda = lambda do |obj, args, ctx|
-            relation = if model_name
-              model_class = resolver_instance.send(:constantize_model, model_name)
-              model_class ? model_class.all : nil
-            elsif relation_name && obj.respond_to?(relation_name)
-              obj.public_send(relation_name)
-            else
-              nil
-            end
+  def self.definition
+    'directive @aggregate(function: String!, column: String, model: String, relation: String) on FIELD_DEFINITION'
+  end
 
-            return nil unless relation
+  def define_resolver(target_type_class)
+    model_name = extract_directive_arg('model')
+    relation_name = extract_directive_arg('relation')
+    column_name = extract_directive_arg('column')
+    function_name = extract_directive_arg('function')
+    resolver_instance = self
+    field_ast_node = @field_def.ast_node
 
-            relation = DirectiveResolvers::BuilderApplier.apply(relation, field_ast_node, args, ctx, resolver_instance)
-            resolver_instance.send(:compute_aggregation, relation, column_name, function_name)
-          end
+    install(target_type_class, lambda do |obj, args, ctx|
+      relation = resolver_instance.send(:aggregate_source, obj, model_name, relation_name)
+      return nil unless relation
 
-          target_type_class.define_singleton_method(method_name, &resolver_lambda)
-          @field_def.resolve_proc = resolver_lambda if @field_def.respond_to?(:resolve_proc=)
-        end
+      relation = Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply(relation, field_ast_node, args, ctx, resolver_instance)
+      resolver_instance.send(:compute_aggregation, relation, column_name, function_name)
+    end)
+  end
 
-        private
+  private
 
-        def extract_directive_arg(name)
-          arg = @directive_node.arguments&.find { |a| a.name == name }
-          return nil unless arg
-          v = arg.value.respond_to?(:value) ? arg.value.value : arg.value
-          v.is_a?(::GraphQL::Language::Nodes::Enum) ? v.name : v
-        end
+  def extract_directive_arg(name)
+    arg = @directive_node.arguments&.find { |a| a.name == name }
+    return nil unless arg
 
-        def compute_aggregation(relation, column, function_name)
-          return nil unless relation.respond_to?(:any?)
-          column = column.to_s
-          case function_name.to_s.upcase
-          when 'SUM'
-            relation.sum(column)
-          when 'AVG'
-            relation.average(column)&.to_f
-          when 'MIN'
-            relation.minimum(column)
-          when 'MAX'
-            relation.maximum(column)
-          when 'COUNT'
-            relation.count
-          else
-            nil
-          end
-        rescue StandardError
-          nil
-        end
+    v = arg.value.respond_to?(:value) ? arg.value.value : arg.value
+    v.is_a?(::GraphQL::Language::Nodes::Enum) ? v.name : v
+  end
 
-        def set_resolve_proc(method_name)
-          if @field_def.respond_to?(:resolve_proc=)
-            @field_def.resolve_proc = ->(obj, arguments, ctx) do
-              target_type_class = self.class
-              if target_type_class.respond_to?(method_name)
-                target_type_class.public_send(method_name, obj, arguments, ctx)
-              else
-                nil
-              end
-            end
-          end
-        end
-      end
+  # The model's table when `model:` is given, else the parent's relation.
+  def aggregate_source(obj, model_name, relation_name)
+    if model_name
+      constantize_model(model_name)&.all
+    elsif relation_name && obj.respond_to?(relation_name)
+      obj.public_send(relation_name)
     end
   end
+
+  def compute_aggregation(relation, column, function_name)
+    return nil unless relation.respond_to?(:any?)
+
+    AGGREGATIONS[function_name.to_s.upcase]&.call(relation, column.to_s)
+  rescue StandardError
+    nil
+  end
+
+  def install_resolve_proc(method_name)
+    return unless @field_def.respond_to?(:resolve_proc=)
+
+    @field_def.resolve_proc = lambda { |obj, arguments, ctx|
+      target_type_class = self.class
+      target_type_class.public_send(method_name, obj, arguments, ctx) if target_type_class.respond_to?(method_name)
+    }
+  end
 end

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