lighthouse-graphql 0.1.0 → 0.2.0

data/lib/lighthouse/directive_resolvers/convention_resolver.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+# Resolves a Query or Mutation field that has no resolving directive by
+# convention, as PHP Lighthouse does: `Query.latestPosts` resolves to
+# `Queries::LatestPosts` (a GraphQL::Schema::Resolver), `Mutation.publishPost`
+# to `Mutations::PublishPost` (a GraphQL::Schema::Mutation), looked up in
+# Config.namespaces[:queries] / [:mutations] at call time so code reloading
+# keeps working. Not a directive: SchemaGenerator installs it.
+class Lighthouse::GraphQL::DirectiveResolvers::ConventionResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def initialize(field_def, type_def, kind)
+    super(field_def, type_def, nil)
+    @kind = kind
+  end
+
+  def define_resolver(target_type_class)
+    me = self
+    inner = capture_inner(target_type_class)
+
+    install(target_type_class, lambda do |obj, args, ctx|
+      me.send(:resolve_by_convention, inner, obj, args, ctx)
+    end)
+  end
+
+  ROOT_KINDS = { 'Query' => :queries, 'Mutation' => :mutations }.freeze
+
+  # :queries / :mutations for the conventional root type names. The
+  # SchemaGenerator passes the schema's actual roots as `root_kind:`.
+  def self.root_kind_of(type)
+    ROOT_KINDS[type.respond_to?(:graphql_name) ? type.graphql_name : type.to_s]
+  end
+
+  private
+
+  def resolve_by_convention(inner, obj, args, ctx)
+    namespaces = Lighthouse::Config.namespaces[@kind]
+    klass = Lighthouse::Support::ModelResolver.constantize(class_name, namespaces: namespaces, fallback: false)
+    return missing(namespaces, inner, obj, args, ctx) unless klass
+
+    unless Lighthouse::GraphQL::ResolverDispatch.graphql_resolver?(klass)
+      raise Lighthouse::DefinitionError,
+            "#{klass} resolves #{location}, so it must inherit from GraphQL::Schema::Resolver " \
+            '(or GraphQL::Schema::Mutation).'
+    end
+
+    Lighthouse::GraphQL::ResolverDispatch.call(klass, @field_def, obj, args, ctx)
+  end
+
+  # No class: the root object may still answer (a custom root_value);
+  # otherwise report the misconfiguration through Config.on_error.
+  def missing(namespaces, inner, obj, args, ctx)
+    return inner.call(obj, args, ctx) if obj && !obj.is_a?(Hash) && obj.respond_to?(@field_def.name)
+
+    expected = Array(namespaces).map { |ns| "#{ns}::#{class_name}" }.join(' or ')
+    Lighthouse::Config.handle_error(
+      Lighthouse::DefinitionError.new("#{location} has no resolver: define #{expected}, or add a resolving directive."),
+      ctx
+    )
+    nil
+  end
+
+  def class_name
+    @class_name ||= @field_def.name.to_s.camelize
+  end
+
+  def location
+    @location ||= "#{@type_def.graphql_name}.#{@field_def.name}"
+  end
+end

data/lib/lighthouse/directive_resolvers/count_resolver.rb

@@ -3,54 +3,48 @@
 require_relative 'base'
 require_relative 'builder_applier'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      # @count(model: "Model", relation: "assoc") — return the number of records.
-      # Counts `Model.all` when `model:` is given, otherwise the named relation on
-      # the parent object (or a relation matching the field name). Honors @builder
-      # and where/argument filters before counting.
-      class CountDirectiveResolver < BaseDirectiveResolver
-        def self.directive_name = 'count'
-        def self.definition = 'directive @count(model: String, relation: String, scopes: [String!]) on FIELD_DEFINITION'
-
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
-          method_name = "resolve_field_#{field_name}"
-          model_name = directive_arg('model')
-          relation_name = directive_arg('relation')
-          resolver_instance = self
-          field_ast_node = @field_def.ast_node
-
-          resolver = lambda do |obj, arguments, ctx|
-            args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-            relation =
-              if model_name
-                model_class = resolver_instance.constantize_model(model_name)
-                model_class&.all
-              elsif relation_name && obj.respond_to?(relation_name)
-                obj.public_send(relation_name)
-              elsif obj.respond_to?(field_name)
-                obj.public_send(field_name)
-              end
-
-            next 0 unless relation.respond_to?(:count)
-
-            relation = DirectiveResolvers::BuilderApplier.apply(relation, field_ast_node, args_h, ctx, resolver_instance)
-            relation = resolver_instance.apply_where_filters(relation, args_h)
-            relation.count
-          end
-
-          target_type_class.define_singleton_method(method_name, &resolver)
-          @field_def.resolve_proc = resolver if @field_def.respond_to?(:resolve_proc=)
-        end
-
-        private
-
-        def directive_arg(name)
-          Lighthouse::Support::DirectiveArgs.literal(@directive_node, name)
-        end
-      end
+# @count(model: "Model", relation: "assoc") — return the number of records.
+# Counts `Model.all` when `model:` is given, otherwise the named relation on
+# the parent object (or a relation matching the field name). Honors `scopes:`, @builder
+# and where/argument filters before counting.
+class Lighthouse::GraphQL::DirectiveResolvers::CountDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'count'
+  def self.definition = 'directive @count(model: String, relation: String, scopes: [String!]) on FIELD_DEFINITION'
+
+  def define_resolver(target_type_class)
+    model_name = directive_arg('model')
+    relation_name = directive_arg('relation')
+    me = self
+
+    install(target_type_class, lambda do |obj, arguments, ctx|
+      me.send(:count_records, me.send(:countable, obj, model_name, relation_name), arguments, ctx)
+    end)
+  end
+
+  private
+
+  def directive_arg(name)
+    Lighthouse::Support::DirectiveArgs.literal(@directive_node, name)
+  end
+
+  def countable(obj, model_name, relation_name)
+    field_name = @field_def.name
+    if model_name
+      constantize_model(model_name)&.all
+    elsif relation_name && obj.respond_to?(relation_name)
+      obj.public_send(relation_name)
+    elsif obj.respond_to?(field_name)
+      obj.public_send(field_name)
     end
   end
+
+  def count_records(relation, arguments, ctx)
+    return 0 unless relation.respond_to?(:count)
+
+    args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
+    relation = apply_scopes(relation)
+    relation = Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply(relation, @field_def.ast_node, args_h, ctx, self)
+    relation = apply_where_filters(relation, args_h)
+    relation.count
+  end
 end

data/lib/lighthouse/directive_resolvers/field_resolver.rb

@@ -2,77 +2,36 @@
 
 require_relative 'base'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      class FieldDirectiveResolver < BaseDirectiveResolver
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
-          method_name = "resolve_field_#{field_name}"
-
-          resolver_class_name = extract_directive_arg('resolver') || extract_directive_arg('class')
-          resolver_instance = self
-
-          resolver = proc do |obj, args, ctx|
-            begin
-              resolver_class = resolver_instance.constantize_model(resolver_class_name)
-              return nil unless resolver_class
-
-              if resolver_class.respond_to?(:call)
-                result = resolver_class.call(obj, args, ctx)
-              else
-                instance = resolver_class.new
-                if instance.respond_to?(:call)
-                  result = instance.call(obj, args, ctx)
-                elsif instance.respond_to?(:resolve)
-                  result = instance.resolve(obj, args, ctx)
-                else
-                  result = nil
-                end
-              end
-
-              result
-            rescue StandardError => e
-              raise e
-            end
-          end
-
-          target_type_class.define_singleton_method(method_name, &resolver)
-
-          if @field_def.respond_to?(:resolve_proc=)
-            @field_def.resolve_proc = resolver
-          end
-        end
+class Lighthouse::GraphQL::DirectiveResolvers::FieldDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'field'
+  def self.definition = 'directive @field(resolver: String, class: String) on FIELD_DEFINITION'
+
+  # On Query and Mutation the class is looked up in the queries / mutations
+  # namespaces; on any other type, in Config.resolver_namespaces.
+  def define_resolver(target_type_class)
+    field_def = @field_def
+    class_name = extract_directive_arg('resolver') || extract_directive_arg('class')
+    kind = root_kind(target_type_class)
+
+    install(target_type_class, lambda do |obj, args, ctx|
+      namespaces = kind ? Lighthouse::Config.namespaces[kind] : Lighthouse::Config.resolver_namespaces
+      klass = Lighthouse::Support::ModelResolver.constantize(class_name, namespaces: namespaces)
+      next nil unless klass
+
+      Lighthouse::GraphQL::ResolverDispatch.call(klass, field_def, obj, args, ctx)
+    end)
+  end
 
-        private
+  private
 
-        def extract_directive_arg(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
+  def extract_directive_arg(name)
+    arg = @directive_node.arguments&.find { |a| a.name == name }
+    return nil unless arg
 
-        def execute_resolver(resolver_class, obj, args, ctx)
-          return nil unless resolver_class
+    arg.value.respond_to?(:value) ? arg.value.value : arg.value
+  end
 
-          if resolver_class.respond_to?(:call)
-            resolver_class.call(obj, args, ctx)
-          elsif resolver_class.respond_to?(:new)
-            instance = resolver_class.new
-            if instance.respond_to?(:call)
-              instance.call(obj, args, ctx)
-            elsif instance.respond_to?(:resolve)
-              instance.resolve(obj, args, ctx)
-            else
-              nil
-            end
-          else
-            nil
-          end
-        rescue StandardError => e
-          raise e
-        end
-      end
-    end
+  def root_kind(target_type_class)
+    @opts[:root_kind] || Lighthouse::GraphQL::DirectiveResolvers::ConventionResolver.root_kind_of(target_type_class)
   end
 end

data/lib/lighthouse/directive_resolvers/find_resolver.rb

@@ -2,64 +2,54 @@
 
 require_relative 'base'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      class FindDirectiveResolver < BaseDirectiveResolver
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
-          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|
-            args = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-            id = args[:id] || args['id']
-
-            model_class = model_class_static
-            return nil unless model_class
+# @find — the single record the field's argument filters select:
+#
+#   user(id: ID! @eq): User @find
+#   userByEmail(email: String! @eq): User @find
+#
+# A lookup by `id` alone is batched through the Dataloader, and an `id`
+# argument without a filter directive selects by primary key. More than one
+# match is an error, as in PHP Lighthouse; none returns null.
+class Lighthouse::GraphQL::DirectiveResolvers::FindDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'find'
+  def self.definition = 'directive @find(model: String, scopes: [String!]) on FIELD_DEFINITION'
+
+  def define_resolver(target_type_class)
+    me = self
+    install(target_type_class, lambda do |_obj, args, ctx|
+      me.send(:find, Lighthouse::Support::Arguments.shallow(args), ctx)
+    end)
+  end
 
-            if id && ctx&.dataloader
-              loader = ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::ModelLoader, model_class)
-              return loader.load(id)
-            end
+  protected
 
-            model_class.find_by(id: id)
-          end
+  def find(args, ctx)
+    model = model_class
+    dataloader = Lighthouse::Support::Batching.dataloader(ctx)
+    return dataloader.with(Lighthouse::GraphQL::DataloaderSources::ModelLoader, model).load(args[:id]) if dataloader && batchable?(args)
 
-          if @field_def.respond_to?(:resolve_proc=)
-            @field_def.resolve_proc = ->(_obj, arguments, ctx) do
-              args = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-              id = args[:id] || args['id']
+    records = find_relation(model, args).limit(2).to_a
+    raise ::GraphQL::ExecutionError, 'The query returned more than one result.' if records.size > 1
 
-              model_class = model_class_static
-              if model_class.nil?
-                nil
-              elsif id && ctx&.dataloader
-                loader = ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::ModelLoader, model_class)
-                loader.load(id)
-              else
-                model_class.find_by(id: id)
-              end
-            end
-          end
-        end
+    records.first
+  end
 
-        private
+  # Only a lookup by `id` alone, with no scopes to apply, can be batched.
+  def batchable?(args)
+    args.keys == [:id] && !directive_arg('scopes')
+  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 find_relation(model, args)
+    relation = apply_scopes(model.all)
+    relation = relation.where(model.primary_key => args[:id]) if args.key?(:id) && !filtered?('id')
+    apply_where_filters(relation, args)
+  end
 
-        def constantize_model(name)
-          return nil unless name
-          name = name.to_s.split('::').last
-          Object.const_get(name) rescue nil
-        end
-      end
-    end
+  # Does the argument carry a filter directive (@eq, @where, ...)? An `id`
+  # without one still selects by primary key.
+  def filtered?(name)
+    argument = (@field_def.ast_node&.arguments || []).find { |a| a.name == name }
+    registry = Lighthouse::DirectiveRegistry.default
+    argument&.directives&.any? { |d| registry.arg_builder_class(d.name) }
   end
 end

data/lib/lighthouse/directive_resolvers/first_resolver.rb

@@ -3,51 +3,45 @@
 require_relative 'base'
 require_relative 'builder_applier'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      # @first(model: "Model") — return a single record (the first match). Like
-      # @all but `.first`, honoring @builder and where/argument filters so it can
-      # be combined with @eq/@where to fetch one record by criteria.
-      class FirstDirectiveResolver < BaseDirectiveResolver
-        def self.directive_name = 'first'
-        def self.definition = 'directive @first(model: String, scopes: [String!]) on FIELD_DEFINITION'
-
-        def define_resolver(target_type_class)
-          method_name = "resolve_field_#{@field_def.name}"
-          model_name_static = directive_arg('model') || field_type_name
-          resolver_instance = self
-          field_ast_node = @field_def.ast_node
-
-          resolver = lambda do |_obj, arguments, ctx|
-            model_class = resolver_instance.constantize_model(model_name_static)
-            next nil unless model_class
-
-            args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-            relation = model_class.all
-            relation = DirectiveResolvers::BuilderApplier.apply(relation, field_ast_node, args_h, ctx, resolver_instance)
-            relation = resolver_instance.apply_where_filters(relation, args_h)
-            relation.first
-          end
-
-          target_type_class.define_singleton_method(method_name, &resolver)
-          @field_def.resolve_proc = resolver if @field_def.respond_to?(:resolve_proc=)
-        end
-
-        private
-
-        def directive_arg(name)
-          Lighthouse::Support::DirectiveArgs.literal(@directive_node, name)
-        end
-
-        def field_type_name
-          unwrapped = @field_def.type.respond_to?(:unwrap) ? @field_def.type.unwrap : @field_def.type
-          return unwrapped.graphql_name if unwrapped.respond_to?(:graphql_name) && unwrapped.graphql_name
-          return unwrapped.name if unwrapped.respond_to?(:name) && unwrapped.name
-
-          @field_def.type.to_type_signature.to_s.gsub(/[!\[\]]/, '')
-        end
-      end
+# @first(model: "Model") — return a single record (the first match). Like
+# @all but `.first`, honoring `scopes:`, @builder and where/argument filters so it can
+# be combined with @eq/@where to fetch one record by criteria.
+class Lighthouse::GraphQL::DirectiveResolvers::FirstDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'first'
+  def self.definition = 'directive @first(model: String, scopes: [String!]) on FIELD_DEFINITION'
+
+  def define_resolver(target_type_class)
+    method_name = "resolve_field_#{@field_def.name}"
+    model_name_static = directive_arg('model') || field_type_name
+    resolver_instance = self
+    field_ast_node = @field_def.ast_node
+
+    resolver = lambda do |_obj, arguments, ctx|
+      model_class = resolver_instance.constantize_model(model_name_static)
+      next nil unless model_class
+
+      args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
+      relation = resolver_instance.apply_scopes(model_class.all)
+      relation = Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply(relation, field_ast_node, args_h, ctx, resolver_instance)
+      relation = resolver_instance.apply_where_filters(relation, args_h)
+      relation.first
     end
+
+    target_type_class.define_singleton_method(method_name, &resolver)
+    @field_def.resolve_proc = resolver if @field_def.respond_to?(:resolve_proc=)
+  end
+
+  private
+
+  def directive_arg(name)
+    Lighthouse::Support::DirectiveArgs.literal(@directive_node, name)
+  end
+
+  def field_type_name
+    unwrapped = @field_def.type.respond_to?(:unwrap) ? @field_def.type.unwrap : @field_def.type
+    return unwrapped.graphql_name if unwrapped.respond_to?(:graphql_name) && unwrapped.graphql_name
+    return unwrapped.name if unwrapped.respond_to?(:name) && unwrapped.name
+
+    @field_def.type.to_type_signature.to_s.gsub(/[!\[\]]/, '')
   end
 end

data/lib/lighthouse/directive_resolvers/guard_resolver.rb

@@ -2,31 +2,25 @@
 
 require_relative 'base'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      # @guard — require an authenticated user before the field resolves.
-      # Wraps the field's resolver; raises "Unauthenticated." when no user is
-      # present (per Config.authenticated_user). Mirrors PHP Lighthouse's @guard.
-      class GuardDirectiveResolver < BaseDirectiveResolver
-        def self.directive_name = 'guard'
-        def self.definition = 'directive @guard on FIELD_DEFINITION'
+# @guard — require an authenticated user before the field resolves.
+# Wraps the field's resolver; raises "Unauthenticated." when no user is
+# present (per Config.authenticated_user). Mirrors PHP Lighthouse's @guard.
+class Lighthouse::GraphQL::DirectiveResolvers::GuardDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'guard'
+  def self.definition = 'directive @guard on FIELD_DEFINITION'
 
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
-          method_name = "resolve_field_#{field_name}"
-          inner = Resolution.capture(target_type_class, method_name, @field_def, field_name)
+  def define_resolver(target_type_class)
+    field_name = @field_def.name
+    method_name = "resolve_field_#{field_name}"
+    inner = Lighthouse::GraphQL::DirectiveResolvers::Resolution.capture(target_type_class, method_name, @field_def, field_name)
 
-          wrapper = lambda do |obj, arguments, ctx|
-            raise(::GraphQL::ExecutionError, 'Unauthenticated.') unless Lighthouse::Support::Authorization.authenticated?(ctx)
+    wrapper = lambda do |obj, arguments, ctx|
+      raise(::GraphQL::ExecutionError, 'Unauthenticated.') unless Lighthouse::Support::Authorization.authenticated?(ctx)
 
-            inner.call(obj, arguments, ctx)
-          end
-
-          target_type_class.define_singleton_method(method_name, &wrapper)
-          @field_def.resolve_proc = wrapper if @field_def.respond_to?(:resolve_proc=)
-        end
-      end
+      inner.call(obj, arguments, ctx)
     end
+
+    target_type_class.define_singleton_method(method_name, &wrapper)
+    @field_def.resolve_proc = wrapper if @field_def.respond_to?(:resolve_proc=)
   end
 end

data/lib/lighthouse/directive_resolvers/method_resolver.rb

@@ -2,34 +2,28 @@
 
 require_relative 'base'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      # @method(name: "someMethod") — resolve the field by calling a method on the
-      # parent object. Mirrors PHP Lighthouse's @method. Defaults to the field's
-      # own (snake_cased) name when `name` is omitted.
-      #
-      #   labels: [String!]! @method(name: "label_list")
-      #   canReply: Boolean   @method(name: "can_reply?")
-      class MethodDirectiveResolver < BaseDirectiveResolver
-        def self.directive_name = 'method'
-        def self.definition = 'directive @method(name: String) on FIELD_DEFINITION'
+# @method(name: "someMethod") — resolve the field by calling a method on the
+# parent object. Mirrors PHP Lighthouse's @method. Defaults to the field's
+# own (snake_cased) name when `name` is omitted.
+#
+#   labels: [String!]! @method(name: "label_list")
+#   canReply: Boolean   @method(name: "can_reply?")
+class Lighthouse::GraphQL::DirectiveResolvers::MethodDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'method'
+  def self.definition = 'directive @method(name: String) on FIELD_DEFINITION'
 
-        def define_resolver(target_type_class)
-          resolver_method = "resolve_field_#{@field_def.name}"
-          target_method = (Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'name') ||
-                           Lighthouse::Support::Naming.attribute(@field_def.name)).to_s
+  def define_resolver(target_type_class)
+    resolver_method = "resolve_field_#{@field_def.name}"
+    target_method = (Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'name') ||
+                     Lighthouse::Support::Naming.attribute(@field_def.name)).to_s
 
-          resolver = lambda do |obj, _arguments, _ctx|
-            next nil if obj.nil?
+    resolver = lambda do |obj, _arguments, _ctx|
+      next nil if obj.nil?
 
-            obj.respond_to?(target_method) ? obj.public_send(target_method) : nil
-          end
-
-          target_type_class.define_singleton_method(resolver_method, &resolver)
-          @field_def.resolve_proc = resolver if @field_def.respond_to?(:resolve_proc=)
-        end
-      end
+      obj.respond_to?(target_method) ? obj.public_send(target_method) : nil
     end
+
+    target_type_class.define_singleton_method(resolver_method, &resolver)
+    @field_def.resolve_proc = resolver if @field_def.respond_to?(:resolve_proc=)
   end
 end