lighthouse-graphql 0.1.1 → 0.2.0

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

data/lib/lighthouse/directive_resolvers/where_conditions_applier.rb

@@ -1,168 +1,169 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      class WhereConditionsApplier
-        # Operator semantics live in Lighthouse::WhereConditions::OperatorMap so
-        # they can be shared with the simple argument-filter directives.
-        SUPPORTED_OPERATORS = Lighthouse::WhereConditions::OperatorMap::OPERATORS
-
-        class << self
-          def apply(relation, value)
-            return relation unless relation.respond_to?(:where)
-            return relation if value.nil?
-
-            condition = value.is_a?(Hash) ? value.deep_symbolize_keys : symbolized(value)
-            return relation unless condition.is_a?(Hash)
-
-            result = relation
-
-            if condition.key?(:AND)
-              Array(condition[:AND]).each do |sub|
-                result = apply(result, sub)
-              end
-            end
-
-            if condition.key?(:OR)
-              or_rel = nil
-              Array(condition[:OR]).each do |sub|
-                sub_scope = apply(relation, sub)
-                or_rel = or_rel ? or_rel.or(sub_scope) : sub_scope
-              end
-              result = or_rel if or_rel
-            end
-
-            if condition.key?(:HAS)
-              has_cond = condition[:HAS]
-              if has_cond.is_a?(Hash) && has_cond[:relation]
-                result = apply_has(result, has_cond)
-              end
-            end
-
-            if condition.key?(:column)
-              result = apply_single_condition(result, condition)
-            end
-
-            result
-          end
-
-          def apply_has(relation, has_cond)
-            relation_name = has_cond[:relation].to_s
-            return relation unless relation_name.present?
-
-            resolved_relation_name = resolve_relation_name(relation, relation_name)
-            return relation unless resolved_relation_name.present?
-
-            source_klass = relation.respond_to?(:klass) ? relation.klass : relation
-            reflection = source_klass.respond_to?(:reflect_on_association) ? source_klass.reflect_on_association(resolved_relation_name.to_sym) : nil
-            return relation unless reflection&.klass
-
-            if has_cond[:condition].present?
-              child_scope = reflection.klass.all
-              child_scope = apply(child_scope, has_cond[:condition])
-
-              # Use an EXISTS-style filter to safely apply conditions from the related model.
-              table_name = reflection.klass.table_name
-              relation.joins(resolved_relation_name.to_sym)
-                      .where(table_name => { id: child_scope.select(:id) })
-                      .distinct
-            else
-              relation.joins(resolved_relation_name.to_sym).distinct
-            end
-          rescue StandardError
-            relation
-          end
-
-          def resolve_relation_name(relation, relation_name)
-            candidate_names = [relation_name.to_s, relation_name.to_s.singularize, relation_name.to_s.pluralize].uniq
-
-            candidate_names.each do |candidate|
-              next if candidate.blank?
-              return candidate if association_exists?(relation, candidate)
-            end
-
-            nil
-          rescue StandardError
-            nil
-          end
-
-          def association_exists?(relation, name)
-            klass = relation.respond_to?(:klass) ? relation.klass : relation
-            return false unless klass.respond_to?(:reflect_on_association)
-
-            klass.reflect_on_association(name.to_sym).present?
-          rescue StandardError
-            false
-          end
-
-          def apply_has_argument(relation, arg_name, arg_value, relation_name = nil)
-            relation_name ||= derive_relation_name(arg_name)
-            return relation unless relation_name.present? && arg_value.present?
-
-            condition = arg_value.is_a?(Hash) ? arg_value : symbolized(arg_value)
-            has_payload = { relation: relation_name, condition: condition }
-            apply_has(relation, has_payload)
-          end
-
-          private
-
-          def derive_relation_name(arg_name)
-            Lighthouse::Support::Naming.derive_relation_name(arg_name)
-          end
-
-          def apply_single_condition(relation, condition)
-            col = condition[:column]
-            op = condition[:operator]&.to_s&.upcase || 'EQ'
-            value = condition[:value]
-
-            return relation if col.blank? || !relation.respond_to?(:where)
-
-            column_name = resolve_column_name(col)
-            return relation if column_name.blank?
-
-            case op
-            when 'IS_NULL'
-              relation.where(column_name => nil)
-            when 'IS_NOT_NULL'
-              relation.where.not(column_name => nil)
-            when 'IN'
-              relation.where(column_name => Array(value))
-            when 'NIN'
-              relation.where.not(column_name => Array(value))
-            when 'CONTAINS'
-              relation.where(arel_table(relation)[column_name].matches("%#{value}%"))
-            when 'STARTS_WITH'
-              relation.where(arel_table(relation)[column_name].matches("#{value}%"))
-            when 'ENDS_WITH'
-              relation.where(arel_table(relation)[column_name].matches("%#{value}"))
-            else
-              if SUPPORTED_OPERATORS[op]
-                relation.where(arel_table(relation)[column_name].public_send(SUPPORTED_OPERATORS[op], value))
-              else
-                relation.where(column_name => value)
-              end
-            end
-          rescue StandardError
-            relation
-          end
-
-          def resolve_column_name(column)
-            Lighthouse::Support::Naming.column(column)
-          end
-
-          def arel_table(relation)
-            relation.klass.arel_table
-          end
-
-          def symbolized(obj)
-            if obj.respond_to?(:to_h)
-              obj.to_h.deep_symbolize_keys
-            else
-              {}
-            end
-          end
-        end
+class Lighthouse::GraphQL::DirectiveResolvers::WhereConditionsApplier
+  # Operator semantics live in Lighthouse::WhereConditions::OperatorMap so
+  # they can be shared with the simple argument-filter directives.
+  SUPPORTED_OPERATORS = Lighthouse::WhereConditions::OperatorMap::OPERATORS
+  # graphql-ruby hands input objects over with Ruby-style keys, so the
+  # generated input's AND/OR/HAS fields arrive as :and/:or/:has.
+  LOGICAL_KEYS = { and: :AND, or: :OR, has: :HAS }.freeze
+
+  class << self
+    def apply(relation, value)
+      return relation unless relation.respond_to?(:where)
+
+      condition = normalize_condition(value)
+      return relation unless condition
+
+      # AND narrows the incoming scope step by step; each OR branch starts
+      # from the incoming scope, and their union replaces it.
+      result = apply_all(relation, condition[:AND])
+      result = apply_any(relation, condition[:OR]) || result
+      result = apply_has_condition(result, condition[:HAS])
+      result = apply_single_condition(result, condition) if condition.key?(:column)
+      result
+    end
+
+    def apply_has(relation, has_cond)
+      relation_name = has_cond[:relation].to_s
+      return relation if relation_name.blank?
+
+      resolved_relation_name = resolve_relation_name(relation, relation_name)
+      return relation if resolved_relation_name.blank?
+
+      reflection = reflection_for(relation, resolved_relation_name)
+      return relation unless reflection&.klass
+
+      joined = relation.joins(resolved_relation_name.to_sym)
+      return joined.distinct if has_cond[:condition].blank?
+
+      # Use an EXISTS-style filter to safely apply conditions from the related model.
+      child_scope = apply(reflection.klass.all, has_cond[:condition])
+      joined.where(reflection.klass.table_name => { id: child_scope.select(:id) }).distinct
+    rescue StandardError
+      relation
+    end
+
+    def resolve_relation_name(relation, relation_name)
+      candidate_names = [relation_name.to_s, relation_name.to_s.singularize, relation_name.to_s.pluralize].uniq
+
+      candidate_names.each do |candidate|
+        next if candidate.blank?
+        return candidate if association_exists?(relation, candidate)
+      end
+
+      nil
+    rescue StandardError
+      nil
+    end
+
+    def association_exists?(relation, name)
+      reflection_for(relation, name).present?
+    rescue StandardError
+      false
+    end
+
+    def apply_has_argument(relation, arg_name, arg_value, relation_name = nil)
+      relation_name ||= derive_relation_name(arg_name)
+      return relation unless relation_name.present? && arg_value.present?
+
+      condition = arg_value.is_a?(Hash) ? arg_value : symbolized(arg_value)
+      has_payload = { relation: relation_name, condition: condition }
+      apply_has(relation, has_payload)
+    end
+
+    private
+
+    # The condition as a symbol-keyed Hash, or nil when there is none.
+    def normalize_condition(value)
+      return nil if value.nil?
+
+      condition = value.is_a?(Hash) ? value.deep_symbolize_keys : symbolized(value)
+      condition.transform_keys { |key| LOGICAL_KEYS.fetch(key, key) } if condition.is_a?(Hash)
+    end
+
+    def apply_all(relation, conditions)
+      Array(conditions).reduce(relation) { |acc, sub| apply(acc, sub) }
+    end
+
+    # The union of the branches, or nil when there are none.
+    def apply_any(relation, conditions)
+      Array(conditions).map { |sub| apply(relation, sub) }.reduce { |acc, sub_scope| acc.or(sub_scope) }
+    end
+
+    def apply_has_condition(relation, has_cond)
+      return relation unless has_cond.is_a?(Hash) && has_cond[:relation]
+
+      apply_has(relation, has_cond)
+    end
+
+    def reflection_for(relation, name)
+      klass = relation.respond_to?(:klass) ? relation.klass : relation
+      klass.reflect_on_association(name.to_sym) if klass.respond_to?(:reflect_on_association)
+    end
+
+    def derive_relation_name(arg_name)
+      Lighthouse::Support::Naming.derive_relation_name(arg_name)
+    end
+
+    def apply_single_condition(relation, condition)
+      return relation if condition[:column].blank? || !relation.respond_to?(:where)
+
+      column_name = resolve_column_name(condition[:column])
+      return relation if column_name.blank?
+
+      apply_operator(relation, column_name, operator_of(condition), condition[:value])
+    rescue StandardError
+      relation
+    end
+
+    def operator_of(condition)
+      condition[:operator]&.to_s&.upcase || 'EQ'
+    end
+
+    # Null and set operators are plain hash conditions; the rest need Arel.
+    def apply_operator(relation, column_name, operator, value)
+      case operator
+      when 'IS_NULL' then relation.where(column_name => nil)
+      when 'IS_NOT_NULL' then relation.where.not(column_name => nil)
+      when 'IN' then relation.where(column_name => Array(value))
+      when 'NIN' then relation.where.not(column_name => Array(value))
+      else apply_arel_operator(relation, column_name, operator, value)
+      end
+    end
+
+    # An unknown operator falls back to equality rather than failing the query.
+    def apply_arel_operator(relation, column_name, operator, value)
+      pattern = like_pattern(operator, value)
+      return relation.where(arel_table(relation)[column_name].matches(pattern)) if pattern
+
+      predicate = SUPPORTED_OPERATORS[operator]
+      return relation.where(column_name => value) unless predicate
+
+      relation.where(arel_table(relation)[column_name].public_send(predicate, value))
+    end
+
+    def like_pattern(operator, value)
+      case operator
+      when 'CONTAINS' then "%#{value}%"
+      when 'STARTS_WITH' then "#{value}%"
+      when 'ENDS_WITH' then "%#{value}"
+      end
+    end
+
+    def resolve_column_name(column)
+      Lighthouse::Support::Naming.column(column)
+    end
+
+    def arel_table(relation)
+      relation.klass.arel_table
+    end
+
+    def symbolized(obj)
+      if obj.respond_to?(:to_h)
+        obj.to_h.deep_symbolize_keys
+      else
+        {}
       end
     end
   end

data/lib/lighthouse/directives/arguments/base.rb

@@ -1,40 +1,32 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  module GraphQL
-    module Directives
-      module Arguments
-        # Base class for argument-builder directives (@eq, @neq, @in, @notIn,
-        # @like, @where, @orderBy). Each receives the argument AST node and the
-        # directive AST node, and composes a constraint onto an ActiveRecord
-        # relation given the client-supplied value for that argument.
-        class Base
-          include Lighthouse::Contracts::ArgBuilder
+# Base class for argument-builder directives (@eq, @neq, @in, @notIn,
+# @like, @where, @orderBy). Each receives the argument AST node and the
+# directive AST node, and composes a constraint onto an ActiveRecord
+# relation given the client-supplied value for that argument.
+class Lighthouse::GraphQL::Directives::Arguments::Base
+  include Lighthouse::Contracts::ArgBuilder
 
-          def initialize(arg_node, directive_node)
-            @arg_node = arg_node
-            @directive_node = directive_node
-          end
+  def initialize(arg_node, directive_node)
+    @arg_node = arg_node
+    @directive_node = directive_node
+  end
 
-          # @return relation
-          def handle_builder(_relation, _value)
-            raise NotImplementedError
-          end
+  # @return relation
+  def handle_builder(_relation, _value)
+    raise NotImplementedError
+  end
 
-          private
+  private
 
-          # Column to filter on: the directive's `key:` argument if present,
-          # otherwise the snake_case form of the GraphQL argument name.
-          def column
-            Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'key') ||
-              Lighthouse::Support::Naming.attribute(@arg_node.name)
-          end
+  # Column to filter on: the directive's `key:` argument if present,
+  # otherwise the snake_case form of the GraphQL argument name.
+  def column
+    Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'key') ||
+      Lighthouse::Support::Naming.attribute(@arg_node.name)
+  end
 
-          def arel_column(relation)
-            relation.klass.arel_table[column]
-          end
-        end
-      end
-    end
+  def arel_column(relation)
+    relation.klass.arel_table[column]
   end
 end