lighthouse-graphql 0.1.1 → 0.2.1

data/lib/lighthouse/directive_resolvers/paginate_resolver.rb

@@ -1,147 +1,89 @@
 # frozen_string_literal: true
 
-require 'ostruct'
 require_relative 'base'
 require_relative 'builder_applier'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      class PaginateDirectiveResolver < BaseDirectiveResolver
-        class PaginatorResult
-          attr_reader :paginator_info, :data
-
-          def initialize(paginator_info:, data:)
-            @paginator_info = paginator_info
-            @data = data
-          end
-
-          def paginatorInfo
-            @paginator_info
-          end
-        end
-
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
-          method_name = "resolve_field_#{field_name}"
-
-          # Resolve model name now, but constantize lazily at call time so
-          # Rails autoloading (Zeitwerk) can load the model after startup.
-          model_name_static = extract_model_name || extract_model_name_from_field_type
-          # If the field was transformed to a Paginator type (e.g. InboxPaginator),
-          # derive the underlying model name by stripping a trailing "Paginator".
-          model_name_static = model_name_static.to_s.sub(/Paginator\z/, '')
-          # Closure to lookup the model class lazily
-          model_lookup = proc { constantize_model(model_name_static) }
-
-
-
-          # Determine whether this paginate directive requested a cursor/connection
-          type_arg = extract_type_name
-          is_connection_type = type_arg && %w[CONNECTION CURSOR].include?(type_arg.to_s.upcase)
-
-          # Paginator object builder (responds to both `paginatorInfo` and `paginator_info`)
-          paginator_builder = proc do |pinfo, data|
-            paginator_info_object = OpenStruct.new(pinfo)
-            # Ensure both camelCase and underscored-methods can be resolved by fallback
-            if pinfo.is_a?(Hash)
-              underscored = {}
-              pinfo.each_key do |k|
-                key = k.to_s
-                snake = key.underscore
-                underscored[snake] = pinfo[k] unless pinfo.key?(snake)
-              end
-              underscored.each { |kk, vv| paginator_info_object[kk] = vv }
-            end
-
-            PaginatorResult.new(paginator_info: paginator_info_object, data: data)
-          end
-
-          # Define owner singleton method to support graphql-ruby's execution
-          resolver_instance = self
-          field_ast_node = @field_def.ast_node
-          target_type_class.define_singleton_method(method_name) do |obj, arguments, ctx|
-            model_class = model_lookup.call
-            return [] unless model_class
-
-            args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-
-            limit = args_h[:first]
-            offset = 0
-            if args_h[:after]
-              begin
-                decoded = Base64.decode64(args_h[:after])
-                if decoded.start_with?('offset:')
-                  offset = decoded.split(':', 2)[1].to_i
-                end
-              rescue StandardError
-                offset = 0
-              end
-            end
+# @paginate — paginate a model query, as PHP Lighthouse does. On a nested
+# field it pages the parent's association of the same name.
+#
+#   users(name: String @like): [User!]! @paginate(defaultCount: 25)
+#
+# `type:` picks PAGINATOR (default), SIMPLE or CONNECTION (see
+# Directives::PaginationManipulator for the generated schema). The query is
+# the model's (`model:`, else the return type), narrowed by `scopes:`,
+# @builder and the field's argument filters (@eq, @where, @orderBy,
+# @whereConditions, ...). `maxCount` caps `first` (null: unlimited),
+# overriding Config.pagination_max_count.
+class Lighthouse::GraphQL::DirectiveResolvers::PaginateDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'paginate'
+
+  def self.definition
+    'directive @paginate(type: PaginateType = PAGINATOR, model: String, scopes: [String!], ' \
+      'defaultCount: Int, maxCount: Int) on FIELD_DEFINITION'
+  end
 
-            relation = model_class.all
+  def self.type_definitions
+    {
+      'PaginateType' => <<~GRAPHQL.chomp
+        "The type of pagination a field uses."
+        enum PaginateType {
+          "Offset-based pagination with page numbers and a total, like Laravel's LengthAwarePaginator."
+          PAGINATOR
+          "Offset-based pagination without a total count, which saves a query."
+          SIMPLE
+          "Cursor-based pagination, compatible with the Relay specification."
+          CONNECTION
+        }
+      GRAPHQL
+    }
+  end
 
-            relation = DirectiveResolvers::BuilderApplier.apply(relation, field_ast_node, args_h, ctx, resolver_instance)
+  def define_resolver(target_type_class)
+    me = self
+    install(target_type_class, lambda do |obj, args, ctx|
+      me.send(:resolve_page, obj, Lighthouse::Support::Arguments.shallow(args), ctx)
+    end)
+  end
 
-            relation = DirectiveResolvers::WhereConditionsApplier.apply(relation, args_h[:where] || args_h['where'])
-            relation = relation.offset(offset) if offset > 0
-            relation = relation.limit(limit) if limit
+  protected
 
-            if is_connection_type
-              ::GraphQL::Pagination::ArrayConnection.new(relation, context: ctx, parent: nil, field: nil, arguments: {})
-            else
-              data = relation.to_a
-              per_page = limit
-              total = relation.count
-              paginator_info = {
-                count: data.size,
-                currentPage: 1,
-                firstItem: data.any? ? (offset + 1) : nil,
-                hasMorePages: (offset + data.size) < total,
-                lastItem: data.any? ? (offset + data.size) : nil,
-                lastPage: per_page && per_page > 0 ? (total.to_f / per_page).ceil : 1,
-                perPage: per_page || data.size,
-                total: total
-              }
+  def resolve_page(obj, args, ctx)
+    Lighthouse::GraphQL::Pagination.paginate(page_list(obj, args, ctx), (directive_arg('type') || 'PAGINATOR').to_s.upcase, args, limits)
+  end
 
-              paginator_builder.call(paginator_info, data)
-            end
-          end
+  # On a nested field, the parent's association of that name (as in PHP
+  # Lighthouse, `User.posts @paginate` pages the user's posts), batched with
+  # the other parents' when the Dataloader can; otherwise, or with `model:`,
+  # the model's whole table.
+  def page_list(obj, args, ctx)
+    name = Lighthouse::Support::Naming.attribute(@field_def.name)
+    return decorate_relation(model_class.all, args, ctx) unless nested?(obj, name)
 
-          # Attach a field-level resolve_proc that delegates to the generated
-          # singleton resolver. This keeps runtime dispatch consistent with
-          # SchemaImplementation (which checks for resolve_field_* first).
-          if @field_def.respond_to?(:resolve_proc=)
-            @field_def.resolve_proc = ->(obj, arguments, ctx) do
-              target_type_class.public_send(method_name, obj, arguments, ctx)
-            end
-          end
-        end
+    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
 
-        private
+    decorate_relation(obj.association(name.to_sym).scope, args, ctx)
+  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 nested?(obj, name)
+    !directive_arg('model') && obj.respond_to?(:association) && obj.class.reflect_on_association(name.to_sym)
+  end
 
+  public
 
-        def extract_type_name
-          arg = @directive_node.arguments&.find { |a| a.name == 'type' }
-          return nil unless arg
-          arg.value.respond_to?(:value) ? arg.value.value : arg.value
-        end
+  # `scopes:`, @builder and the argument filters, on one relation or a RelationBatch.
+  def decorate_relation(relation, args, ctx)
+    relation = Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply(apply_scopes(relation), @field_def.ast_node, args, ctx, self)
+    apply_where_filters(relation, args)
+  end
 
-        def extract_model_name_from_field_type
-          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
+  protected
 
-          # fallback for late-bound signatures like "InboxPaginator!"
-          @field_def.type.to_type_signature.to_s.gsub(/[!\[\]]/, '')
-        end
-      end
-    end
+  def limits
+    limits = { default_count: directive_arg('defaultCount') }
+    given = @directive_node.arguments.any? { |a| a.name == 'maxCount' }
+    limits[:max_count] = directive_arg('maxCount') || :unlimited if given
+    limits
   end
 end

data/lib/lighthouse/directive_resolvers/rename_resolver.rb

@@ -2,34 +2,28 @@
 
 require_relative 'base'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      # @rename(attribute: "snake_case_name") — explicit override of the default
-      # field reader. Reads the named attribute off the parent object regardless
-      # of the GraphQL field name.
-      class RenameDirectiveResolver < BaseDirectiveResolver
-        def self.directive_name = 'rename'
-        def self.definition = 'directive @rename(attribute: String!) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION'
+# @rename(attribute: "snake_case_name") — explicit override of the default
+# field reader. Reads the named attribute off the parent object regardless
+# of the GraphQL field name.
+class Lighthouse::GraphQL::DirectiveResolvers::RenameDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'rename'
+  def self.definition = 'directive @rename(attribute: String!) on FIELD_DEFINITION | ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
 
-        def define_resolver(target_type_class)
-          method_name = "resolve_field_#{@field_def.name}"
-          attribute = Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'attribute').to_s
+  def define_resolver(target_type_class)
+    method_name = "resolve_field_#{@field_def.name}"
+    attribute = Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'attribute').to_s
 
-          resolver = lambda do |obj, _arguments, _ctx|
-            next nil if obj.nil?
+    resolver = lambda do |obj, _arguments, _ctx|
+      next nil if obj.nil?
 
-            if obj.is_a?(Hash)
-              obj[attribute] || obj[attribute.to_sym]
-            elsif obj.respond_to?(attribute)
-              obj.public_send(attribute)
-            end
-          end
-
-          target_type_class.define_singleton_method(method_name, &resolver)
-          @field_def.resolve_proc = resolver if @field_def.respond_to?(:resolve_proc=)
-        end
+      if obj.is_a?(Hash)
+        obj[attribute] || obj[attribute.to_sym]
+      elsif obj.respond_to?(attribute)
+        obj.public_send(attribute)
       end
     end
+
+    target_type_class.define_singleton_method(method_name, &resolver)
+    @field_def.resolve_proc = resolver if @field_def.respond_to?(:resolve_proc=)
   end
 end

data/lib/lighthouse/directive_resolvers/resolution.rb

@@ -1,35 +1,39 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      # Helper for "middleware" directives (@guard, @can) that need to wrap a
-      # field's existing resolver.
-      module Resolution
-        module_function
+# Helper for "middleware" directives (@guard, @can) that need to wrap a
+# field's existing resolver.
+module Lighthouse::GraphQL::DirectiveResolvers::Resolution
+  module_function
 
-        # Capture the field's current resolver (generated singleton method,
-        # resolve_proc, or the default attribute reader) as a callable
-        # (obj, args, ctx) -> value, so it can be wrapped. The returned callable
-        # is unaffected by subsequently redefining the singleton method.
-        def capture(target_type_class, method_name, field_def, field_name)
-          original_singleton = target_type_class.method(method_name) if target_type_class.respond_to?(method_name)
-          original_proc = field_def.resolve_proc if field_def.respond_to?(:resolve_proc) && field_def.resolve_proc
+  # Capture the field's current resolver (generated singleton method,
+  # resolve_proc, or the default attribute reader) as a callable
+  # (obj, args, ctx) -> value, so it can be wrapped. The returned callable
+  # is unaffected by subsequently redefining the singleton method.
+  def capture(target_type_class, method_name, field_def, field_name)
+    original_singleton = lighthouse_singleton(target_type_class, method_name)
+    original_proc = field_def.resolve_proc if field_def.respond_to?(:resolve_proc) && field_def.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)
-            elsif obj.respond_to?(field_name)
-              obj.public_send(field_name)
-            else
-              snake = Lighthouse::Support::Naming.attribute(field_name)
-              obj.respond_to?(snake) ? obj.public_send(snake) : nil
-            end
-          end
-        end
+    lambda do |obj, arguments, ctx|
+      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 = Lighthouse::Support::Naming.attribute(field_name)
+        obj.respond_to?(snake) ? obj.public_send(snake) : nil
       end
     end
   end
+
+  # graphql-ruby's SDL builder defines `resolve_field_*` methods of its own
+  # (with a different arity); only ours, defined under lib/lighthouse/, count.
+  def lighthouse_singleton(target_type_class, method_name)
+    return nil unless target_type_class.respond_to?(method_name)
+
+    method = target_type_class.method(method_name)
+    source_file, = method.source_location
+    method if source_file&.include?('/lib/lighthouse/')
+  end
 end

data/lib/lighthouse/directive_resolvers/validator_resolver.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+# @validator — validate arguments with a contract class before the field
+# resolves, as PHP Lighthouse's validator classes do.
+#
+#   type Mutation { updateUser(id: ID!, name: String): User @update @validator }
+#   input CreatePostInput @validator { title: String }
+#
+# On a field, the contract gets all the field's arguments; the class
+# defaults to Validators::<ParentType>::<FieldName>Validator. On an input
+# type it gets that input's values wherever the type is used — nested,
+# and per item of a list — defaulting to Validators::<InputType>Validator.
+# Classes are looked up in Config.namespaces[:validators].
+#
+# A contract is a Dry::Validation::Contract (values arrive with
+# snake_case symbol keys; declare `option :graphql_context` to receive the
+# GraphQL context), or any object whose `call(values)` returns such a
+# result or a { key => [messages] } Hash. Failures raise one
+# Lighthouse::ValidationError keyed by GraphQL argument path.
+#
+# Model validations need no directive: @create/@update report them the
+# same way. Use @validator for rules that are not the model's — checks
+# across arguments, arguments of a query, or input that never reaches a model.
+class Lighthouse::GraphQL::DirectiveResolvers::ValidatorDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'validator'
+  def self.definition = 'directive @validator(class: String) on FIELD_DEFINITION | INPUT_OBJECT'
+
+  # A default name, e.g. Mutation::SignUpValidator: always looked up under
+  # the validators namespaces, although it contains `::`.
+  Conventional = Struct.new(:name) do
+    def to_s = name
+  end
+
+  # One validation of a field: the GraphQL context the contracts receive,
+  # and the messages collected so far, keyed by argument path.
+  Pass = Struct.new(:ctx, :messages)
+
+  # Does any input type the field takes (at any depth) carry @validator?
+  def self.input_validators?(field_def, seen = Set.new)
+    field_def.arguments.each_value.any? do |argument|
+      type = argument.type.unwrap
+      next false unless type.kind.input_object? && seen.add?(type.graphql_name)
+
+      validator_directive(type) || input_validators?(type, seen)
+    end
+  end
+
+  def self.validator_directive(type)
+    type.ast_node&.directives&.find { |d| d.name == 'validator' }
+  end
+
+  def define_resolver(target_type_class)
+    me = self
+    field_contract =
+      (directive_arg('class') || Conventional.new("#{@type_def.graphql_name}::#{@field_def.name.to_s.camelize}Validator") if @directive_node)
+    inner = capture_inner(target_type_class)
+
+    install(target_type_class, lambda do |obj, args, ctx|
+      me.send(:validate!, field_contract, args, ctx)
+      inner.call(obj, args, ctx)
+    end)
+  end
+
+  protected
+
+  def validate!(field_contract, args, ctx)
+    values = Lighthouse::Support::Arguments.plain(args)
+    pass = Pass.new(ctx, {})
+    run(field_contract, values, [], @field_def.arguments, pass) if field_contract
+    validate_inputs(@field_def.arguments, values, [], pass)
+    raise Lighthouse::ValidationError.new(@field_def.name, pass.messages) unless pass.messages.empty?
+  end
+
+  def validate_inputs(argument_defs, values, prefix, pass)
+    by_keyword = Lighthouse::Support::Arguments.keyword_index(argument_defs)
+    values.each do |key, value|
+      argument = by_keyword[key.to_sym]
+      next if argument.nil? || value.nil?
+
+      type = argument.type.unwrap
+      next unless type.kind.input_object?
+
+      input_items(value, prefix + [argument.graphql_name]).each do |item, item_path|
+        validate_input(type, item, item_path, pass)
+      end
+    end
+  end
+
+  # One input object value: its own @validator contract, then its nested inputs.
+  def validate_input(type, values, path, pass)
+    directive = self.class.validator_directive(type)
+    if directive
+      name = Lighthouse::Support::DirectiveArgs.literal(directive, 'class') || Conventional.new("#{type.graphql_name}Validator")
+      run(name, values, path, type.arguments, pass)
+    end
+    validate_inputs(type.arguments, values, path, pass)
+  end
+
+  def run(class_name, values, prefix, argument_defs, pass)
+    contract = instantiate(validator_class(class_name), pass.ctx)
+    errors = error_hash(contract.call(values))
+
+    flatten(errors).each do |segments, list|
+      path = (prefix + graphql_path(segments, argument_defs)).join('.')
+      (pass.messages[path.empty? ? @field_def.name : path] ||= []).concat(list)
+    end
+  end
+
+  private
+
+  # A list value validates per item, its path extended by the index.
+  def input_items(value, path)
+    items = Lighthouse::Support::Arguments.list(value)
+    return [[value, path]] unless items
+
+    items.each_with_index.map { |item, i| [item, path + [i.to_s]] }
+  end
+
+  # A contract answers a { key => [messages] } Hash, or a Dry::Validation
+  # result whose message set converts to one.
+  def error_hash(result)
+    return result if result.is_a?(Hash)
+    return {} if result.respond_to?(:success?) && result.success?
+
+    message_set = result.errors
+    message_set.to_h
+  end
+
+  def validator_class(name)
+    namespaces = Lighthouse::Config.namespaces[:validators]
+    found =
+      if name.is_a?(Conventional)
+        namespaces.lazy.filter_map { |ns| Lighthouse::Support::ModelResolver.constantize("#{ns}::#{name}") }.first
+      else
+        Lighthouse::Support::ModelResolver.constantize(name, namespaces: namespaces)
+      end
+    found ||
+      raise(Lighthouse::DefinitionError,
+            "@validator on #{@type_def.graphql_name}.#{@field_def.name}: no validator class #{name} " \
+            "in #{Lighthouse::Config.namespaces[:validators].join(', ')}")
+  end
+
+  def instantiate(klass, ctx)
+    return klass unless klass.is_a?(Class)
+    return klass.new(graphql_context: ctx) if dry_option?(klass, :graphql_context)
+
+    klass.new
+  end
+
+  def dry_option?(klass, name)
+    klass.respond_to?(:dry_initializer) && klass.dry_initializer.options.any? { |option| option.target == name }
+  end
+
+  # Dry's nested errors hash as [[key, ...], [messages]] pairs; base errors
+  # use a nil key.
+  def flatten(errors, prefix = [])
+    errors.flat_map do |key, value|
+      path = key.nil? ? prefix : prefix + [key]
+      case value
+      when Hash then flatten(value, path)
+      when Array then flatten_messages(value, path)
+      else [[path, [value.to_s]]]
+      end
+    end
+  end
+
+  # A key with both its own messages and nested ones comes as
+  # [messages, { nested }].
+  def flatten_messages(value, path)
+    if value.length == 2 && value.first.is_a?(Array) && value.last.is_a?(Hash)
+      [[path, value.first]] + flatten(value.last, path)
+    else
+      [[path, value.map(&:to_s)]]
+    end
+  end
+
+  # Map snake_case contract keys back to the GraphQL argument names.
+  def graphql_path(segments, argument_defs)
+    defs = argument_defs
+    segments.map do |segment|
+      next segment.to_s if segment.is_a?(Integer)
+
+      argument = Lighthouse::Support::Arguments.keyword_index(defs)[segment.to_sym]
+      next segment.to_s.camelize(:lower) unless argument
+
+      type = argument.type.unwrap
+      defs = type.kind.input_object? ? type.arguments : {}
+      argument.graphql_name
+    end
+  end
+end