lighthouse-graphql 0.1.1 → 0.2.1

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

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

@@ -2,100 +2,120 @@
 
 require_relative 'base'
 
-module Lighthouse
-  module GraphQL
-    module Directives
-      module Arguments
-        # @eq — equality filter (the default). `field(status: String @eq)`
-        class Eq < Base
-          def self.directive_name = 'eq'
-          def self.definition = 'directive @eq(key: String) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
-
-          def handle_builder(relation, value)
-            return relation if value.nil?
-
-            relation.where(column => value)
-          end
-        end
-
-        # @neq — inequality filter.
-        class Neq < Base
-          def self.directive_name = 'neq'
-          def self.definition = 'directive @neq(key: String) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
-
-          def handle_builder(relation, value)
-            return relation if value.nil?
-
-            relation.where.not(column => value)
-          end
-        end
-
-        # @in — value is one of a list.
-        class In < Base
-          def self.directive_name = 'in'
-          def self.definition = 'directive @in(key: String) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
-
-          def handle_builder(relation, value)
-            return relation if value.nil?
-
-            relation.where(column => Array(value))
-          end
-        end
-
-        # @notIn — value is none of a list.
-        class NotIn < Base
-          def self.directive_name = 'notIn'
-          def self.definition = 'directive @notIn(key: String) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
-
-          def handle_builder(relation, value)
-            return relation if value.nil?
-
-            relation.where.not(column => Array(value))
-          end
-        end
-
-        # @like — SQL LIKE with the value wrapped in wildcards.
-        class Like < Base
-          def self.directive_name = 'like'
-          def self.definition = 'directive @like(key: String) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
-
-          def handle_builder(relation, value)
-            return relation if value.nil?
-
-            relation.where(arel_column(relation).matches("%#{value}%"))
-          end
-        end
-
-        # @where — generic operator filter, sharing the SQLOperator semantics with
-        # the @whereConditions extension. `field(age: Int @where(operator: "GT"))`
-        class Where < Base
-          def self.directive_name = 'where'
-          def self.definition = 'directive @where(key: String, operator: String) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
-
-          def handle_builder(relation, value)
-            return relation if value.nil?
-
-            op = (Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'operator') || 'EQ').to_s.upcase
-
-            case op
-            when 'IN' then relation.where(column => Array(value))
-            when 'NIN' then relation.where.not(column => Array(value))
-            when 'IS_NULL' then relation.where(column => nil)
-            when 'IS_NOT_NULL' then relation.where.not(column => nil)
-            when 'CONTAINS' then relation.where(arel_column(relation).matches("%#{value}%"))
-            when 'STARTS_WITH' then relation.where(arel_column(relation).matches("#{value}%"))
-            when 'ENDS_WITH' then relation.where(arel_column(relation).matches("%#{value}"))
-            else
-              arel_method = Lighthouse::WhereConditions::OperatorMap[op]
-              if arel_method
-                relation.where(arel_column(relation).public_send(arel_method, value))
-              else
-                relation.where(column => value)
-              end
-            end
-          end
-        end
+module Lighthouse::GraphQL::Directives::Arguments
+  # @eq — equality filter (the default). `field(status: String @eq)`
+  class Eq < Base
+    def self.directive_name = 'eq'
+    def self.definition = 'directive @eq(key: String) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
+
+    def handle_builder(relation, value)
+      return relation if value.nil?
+
+      relation.where(column => value)
+    end
+  end
+
+  # @whereKey — filter by the model's primary key, whatever its column is
+  # named; a list matches any of its values. `deletePosts(ids: [ID!]! @whereKey)`
+  class WhereKey < Base
+    def self.directive_name = 'whereKey'
+    def self.definition = 'directive @whereKey on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
+
+    def handle_builder(relation, value)
+      return relation if value.nil?
+
+      relation.where(relation.klass.primary_key => value)
+    end
+  end
+
+  # @neq — inequality filter.
+  class Neq < Base
+    def self.directive_name = 'neq'
+    def self.definition = 'directive @neq(key: String) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
+
+    def handle_builder(relation, value)
+      return relation if value.nil?
+
+      relation.where.not(column => value)
+    end
+  end
+
+  # @in — value is one of a list.
+  class In < Base
+    def self.directive_name = 'in'
+    def self.definition = 'directive @in(key: String) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
+
+    def handle_builder(relation, value)
+      return relation if value.nil?
+
+      relation.where(column => Array(value))
+    end
+  end
+
+  # @notIn — value is none of a list.
+  class NotIn < Base
+    def self.directive_name = 'notIn'
+    def self.definition = 'directive @notIn(key: String) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
+
+    def handle_builder(relation, value)
+      return relation if value.nil?
+
+      relation.where.not(column => Array(value))
+    end
+  end
+
+  # @like — SQL LIKE with the value wrapped in wildcards.
+  class Like < Base
+    def self.directive_name = 'like'
+    def self.definition = 'directive @like(key: String) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
+
+    def handle_builder(relation, value)
+      return relation if value.nil?
+
+      relation.where(arel_column(relation).matches("%#{value}%"))
+    end
+  end
+
+  # @where — generic operator filter, sharing the SQLOperator semantics with
+  # the @whereConditions extension. `field(age: Int @where(operator: "GT"))`
+  class Where < Base
+    def self.directive_name = 'where'
+    def self.definition = 'directive @where(key: String, operator: String) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
+
+    # LIKE pattern of each wildcard operator, built from the client value.
+    LIKE_PATTERNS = {
+      'CONTAINS' => ->(value) { "%#{value}%" },
+      'STARTS_WITH' => ->(value) { "#{value}%" },
+      'ENDS_WITH' => ->(value) { "%#{value}" }
+    }.freeze
+
+    def handle_builder(relation, value)
+      return relation if value.nil?
+
+      operator = sql_operator
+      case operator
+      when 'IN' then relation.where(column => Array(value))
+      when 'NIN' then relation.where.not(column => Array(value))
+      when 'IS_NULL' then relation.where(column => nil)
+      when 'IS_NOT_NULL' then relation.where.not(column => nil)
+      when *LIKE_PATTERNS.keys then relation.where(arel_column(relation).matches(LIKE_PATTERNS[operator].call(value)))
+      else compare(relation, operator, value)
       end
     end
+
+    private
+
+    def sql_operator
+      (Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'operator') || 'EQ').to_s.upcase
+    end
+
+    # Comparison operators map onto Arel predicates; an unknown one falls
+    # back to equality.
+    def compare(relation, operator, value)
+      arel_method = Lighthouse::WhereConditions::OperatorMap[operator]
+      return relation.where(column => value) unless arel_method
+
+      relation.where(arel_column(relation).public_send(arel_method, value))
+    end
   end
 end