bharat_filter_engine 0.1.2 → 0.2.0

data/lib/bharat_filter_engine/rule_normalizer.rb

@@ -2,46 +2,104 @@
 
 module BharatFilterEngine
   class RuleNormalizer
+    KNOWN_FILTER_TYPES = %i[
+      string
+      array
+      boolean
+      integer
+      float
+      daterange
+      search
+      presence
+    ].freeze
+
+    KNOWN_RANGE_TYPES = %i[gte lte between].freeze
+    NUMERIC_FILTER_TYPES = %i[integer float].freeze
+    NEGATE_UNSUPPORTED_FILTER_TYPES = %i[daterange search presence].freeze
+
     def self.call(rule)
       return nil unless rule
 
-      rule = rule.transform_keys(&:to_sym)
+      normalized = normalize(rule.transform_keys(&:to_sym))
+      validate!(normalized)
+      normalized
+    end
 
+    def self.normalize(rule)
       return rule if rule[:filter_type].present?
 
-      # Legacy configuration support.
-      #
-      # Old:
-      # {
-      #   type: :string,
-      #   dbcolumn: :stage
-      # }
-      #
-      # New:
-      # {
-      #   type: :single,
-      #   filter_type: :string,
-      #   dbcolumn: :stage
-      # }
-
-      scope_type =
-        if rule[:type] == :nested
-          :nested
-        else
-          :single
-        end
-
-      filter_type =
-        if rule[:type] == :nested
-          rule[:filter_type]
-        else
-          rule[:type]
-        end
+      scope_type = rule[:type] == :nested ? :nested : :single
+      filter_type = rule[:type] == :nested ? rule[:filter_type] : rule[:type]
 
       rule.merge(
         type: scope_type,
         filter_type: filter_type
       )
     end
+    private_class_method :normalize
+
+    def self.validate!(rule)
+      filter_type = rule[:filter_type]
+
+      unless KNOWN_FILTER_TYPES.include?(filter_type)
+        raise InvalidConfigurationError,
+              "BharatFilterEngine: unknown filter_type #{filter_type.inspect}. " \
+              "Expected one of #{KNOWN_FILTER_TYPES.inspect}."
+      end
+
+      if rule[:type] == :nested && rule[:association].blank?
+        raise InvalidConfigurationError,
+              'BharatFilterEngine: a `type: :nested` filter rule requires ' \
+              'an `association:` key.'
+      end
+
+      if rule[:type] == :nested && filter_type == :search
+        raise InvalidConfigurationError,
+              'BharatFilterEngine: `filter_type: :search` does not support ' \
+              '`type: :nested` -- use `__` notation inside `dbcolumns:` instead.'
+      end
+
+      if filter_type == :search
+        if Array(rule[:dbcolumns]).empty?
+          raise InvalidConfigurationError,
+                'BharatFilterEngine: a `filter_type: :search` rule requires ' \
+                'a non-empty `dbcolumns:` array.'
+        end
+      elsif rule[:dbcolumn].blank?
+        raise InvalidConfigurationError,
+              'BharatFilterEngine: filter rule requires a `dbcolumn:` key.'
+      end
+
+      validate_range_type!(rule, filter_type)
+      validate_negate!(rule, filter_type)
+    end
+    private_class_method :validate!
+
+    def self.validate_range_type!(rule, filter_type)
+      return unless rule[:range_type]
+
+      unless KNOWN_RANGE_TYPES.include?(rule[:range_type])
+        raise InvalidConfigurationError,
+              "BharatFilterEngine: unknown range_type #{rule[:range_type].inspect}. " \
+              "Expected one of #{KNOWN_RANGE_TYPES.inspect}."
+      end
+
+      return if NUMERIC_FILTER_TYPES.include?(filter_type)
+
+      raise InvalidConfigurationError,
+            'BharatFilterEngine: `range_type:` is only supported for ' \
+            "#{NUMERIC_FILTER_TYPES.inspect} filters, got #{filter_type.inspect}."
+    end
+    private_class_method :validate_range_type!
+
+    def self.validate_negate!(rule, filter_type)
+      return unless rule[:negate]
+      return if rule[:range_type].blank? && !NEGATE_UNSUPPORTED_FILTER_TYPES.include?(filter_type)
+
+      raise InvalidConfigurationError,
+            'BharatFilterEngine: `negate: true` is not supported together ' \
+            "with `range_type:`, or with #{NEGATE_UNSUPPORTED_FILTER_TYPES.inspect} filters."
+    end
+    private_class_method :validate_negate!
   end
-end
+end

data/lib/bharat_filter_engine/search_builder.rb

@@ -2,10 +2,22 @@
 
 module BharatFilterEngine
   class SearchBuilder
-    def initialize(scope:, allowed_columns:)
+    LIKE_ESCAPE_CHAR = '\\'
+
+    def initialize(scope:, allowed_columns:, tracker: nil)
       @scope = scope
+      @tracker = tracker || JoinTracker.new(scope.klass)
       @allowed_columns =
         Array(allowed_columns).map(&:to_s)
+
+      if @allowed_columns.present? &&
+         @allowed_columns.none? { |field| valid_field?(field) }
+
+        raise InvalidConfigurationError,
+              'BharatFilterEngine: none of the configured allowed_columns ' \
+              "#{@allowed_columns.inspect} could be resolved on " \
+              "#{@scope.klass}. Check `dbcolumns:` in your filter config."
+      end
     end
 
     def apply(value)
@@ -13,7 +25,7 @@ module BharatFilterEngine
 
       search = value.to_s.strip
 
-      if search.include?("=")
+      if search.include?('=')
         field_based_search(search)
       else
         simple_search(search)
@@ -23,13 +35,13 @@ module BharatFilterEngine
     private
 
     def simple_search(search)
-      query = "%#{search}%"
+      query = like_query(search)
       conditions = []
 
       @allowed_columns.each do |dbcolumn|
         next unless valid_field?(dbcolumn)
 
-        if dbcolumn.include?("__")
+        if dbcolumn.include?('__')
           @scope, condition =
             nested_condition(
               @scope,
@@ -41,7 +53,7 @@ module BharatFilterEngine
         else
           table = @scope.klass.arel_table
 
-          conditions << table[dbcolumn].matches(query)
+          conditions << table[dbcolumn].matches(query, LIKE_ESCAPE_CHAR)
         end
       end
 
@@ -60,19 +72,20 @@ module BharatFilterEngine
     # is skipped and unrelated records leak through unfiltered.
     def field_based_search(search)
       and_conditions =
-        search.split("&").map do |and_group|
+        search.split('&').map do |and_group|
           or_conditions =
-            and_group.split("|").filter_map do |expression|
+            and_group.split('|').filter_map do |expression|
               field, search_value =
-                expression.split("=", 2)
+                expression.split('=', 2)
 
               next if field.blank?
               next if search_value.blank?
+              next unless @allowed_columns.include?(field)
               next unless valid_field?(field)
 
-              query = "%#{search_value.strip}%"
+              query = like_query(search_value.strip)
 
-              if field.include?("__")
+              if field.include?('__')
                 @scope, condition =
                   nested_condition(
                     @scope,
@@ -81,17 +94,17 @@ module BharatFilterEngine
                   )
 
                 condition
-              elsif field == "id"
+              elsif field == 'id'
                 quoted_column =
                   @scope.klass
                         .connection
                         .quote_column_name(field)
 
                 Arel.sql(
-                  "#{@scope.klass.quoted_table_name}.#{quoted_column}::text"
-                ).matches(query)
+                  "CAST(#{@scope.klass.quoted_table_name}.#{quoted_column} AS TEXT)"
+                ).matches(query, LIKE_ESCAPE_CHAR)
               else
-                @scope.klass.arel_table[field].matches(query)
+                @scope.klass.arel_table[field].matches(query, LIKE_ESCAPE_CHAR)
               end
             end
 
@@ -110,7 +123,7 @@ module BharatFilterEngine
     end
 
     def valid_field?(field)
-      if field.include?("__")
+      if field.include?('__')
         !resolver.resolve_column(field).nil?
       else
         @scope.klass.column_names.include?(field)
@@ -121,21 +134,32 @@ module BharatFilterEngine
       result = resolver.resolve_column(field)
 
       return [scope, nil] unless result
+      return [scope, subquery_condition(result, query)] if @tracker.claim(result) == :subquery
 
-      joined_scope =
-        resolver.join(
-          scope,
-          result[:associations]
-        )
+      joined_scope = resolver.join(scope, result[:associations]).distinct
 
-      condition =
-        result[:klass]
-          .arel_table[result[:column]]
-          .matches(query)
+      condition = result[:klass].arel_table[result[:column]].matches(query, LIKE_ESCAPE_CHAR)
 
       [joined_scope, condition]
     end
 
+    # `primary_key IN (SELECT ... JOIN ... WHERE column LIKE ...)` for a nested column whose
+    # table is already joined through another path (e.g. client + referrer -> clients).
+    def subquery_condition(result, query)
+      klass = @scope.klass
+      matcher = result[:klass].arel_table[result[:column]].matches(query, LIKE_ESCAPE_CHAR)
+      subquery = resolver.subquery(result[:associations]) { |relation| relation.where(matcher) }
+
+      klass.arel_table[klass.primary_key].in(subquery.arel)
+    end
+
+    def like_query(term)
+      escaped =
+        term.to_s.gsub(/[\\%_]/) { |char| "#{LIKE_ESCAPE_CHAR}#{char}" }
+
+      "%#{escaped}%"
+    end
+
     # AssociationResolver only needs @scope.klass (which never changes
     # across joins), so a single instance can be reused for the whole
     # search instead of being rebuilt every time the scope is updated.

data/lib/bharat_filter_engine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BharatFilterEngine
-  VERSION = "0.1.2"
+  VERSION = '0.2.0'
 end

data/lib/bharat_filter_engine.rb

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
-require "active_record"
-require "active_model"
-require "active_support"
-require "json"
+require 'active_record'
+require 'active_model'
+require 'active_support'
+require 'json'
 
-require_relative "bharat_filter_engine/version"
-require_relative "bharat_filter_engine/errors"
-require_relative "bharat_filter_engine/association_resolver"
-require_relative "bharat_filter_engine/rule_normalizer"
-require_relative "bharat_filter_engine/search_builder"
-require_relative "bharat_filter_engine/dynamic_filter_values"
-require_relative "bharat_filter_engine/engine"
+require_relative 'bharat_filter_engine/version'
+require_relative 'bharat_filter_engine/errors'
+require_relative 'bharat_filter_engine/association_resolver'
+require_relative 'bharat_filter_engine/column_helper'
+require_relative 'bharat_filter_engine/rule_normalizer'
+require_relative 'bharat_filter_engine/search_builder'
+require_relative 'bharat_filter_engine/dynamic_filter_values'
+require_relative 'bharat_filter_engine/join_tracker'
+require_relative 'bharat_filter_engine/engine'
 
 module BharatFilterEngine
   class << self
@@ -31,4 +33,4 @@ module BharatFilterEngine
       )
     end
   end
-end
+end

data/spec/association_resolver_spec.rb

@@ -1,19 +1,17 @@
 # frozen_string_literal: true
 
-require "spec_helper"
+require 'spec_helper'
 
 RSpec.describe BharatFilterEngine::AssociationResolver do
-
   let(:resolver) do
     described_class.new(
       Sale.all
     )
   end
 
-  describe "#resolve" do
-
-    it "resolves a direct association" do
-      result = resolver.resolve("lead")
+  describe '#resolve' do
+    it 'resolves a direct association' do
+      result = resolver.resolve('lead')
 
       expect(result[:associations]).to eq(
         [:lead]
@@ -24,13 +22,13 @@ RSpec.describe BharatFilterEngine::AssociationResolver do
       )
     end
 
-    it "resolves nested associations" do
+    it 'resolves nested associations' do
       result = resolver.resolve(
-        "lead__client"
+        'lead__client'
       )
 
       expect(result[:associations]).to eq(
-        [:lead, :client]
+        %i[lead client]
       )
 
       expect(result[:klass]).to eq(
@@ -38,16 +36,16 @@ RSpec.describe BharatFilterEngine::AssociationResolver do
       )
     end
 
-    it "resolves multi-level associations" do
+    it 'resolves multi-level associations' do
       result = resolver.resolve(
-        "lead__client__organization"
+        'lead__client__organization'
       )
 
       expect(result[:associations]).to eq(
-        [
-          :lead,
-          :client,
-          :organization
+        %i[
+          lead
+          client
+          organization
         ]
       )
 
@@ -56,38 +54,51 @@ RSpec.describe BharatFilterEngine::AssociationResolver do
       )
     end
 
-    it "returns nil for invalid association" do
+    it 'returns nil for invalid association' do
       result = resolver.resolve(
-        "unknown"
+        'unknown'
       )
 
       expect(result).to be_nil
     end
-  end
 
-  describe "#resolve_column" do
+    it 'returns nil when an intermediate association in a multi-level path is invalid' do
+      result = resolver.resolve(
+        'lead__not_a_real_association__name'
+      )
 
-    it "resolves direct columns" do
+      expect(result).to be_nil
+    end
+
+    it 'returns nil for a blank path' do
+      result = resolver.resolve('')
+
+      expect(result).to be_nil
+    end
+  end
+
+  describe '#resolve_column' do
+    it 'resolves direct columns' do
       result =
         resolver.resolve_column(
-          "stage"
+          'stage'
         )
 
       expect(result[:column]).to eq(
-        "stage"
+        'stage'
       )
 
       expect(result[:associations]).to eq([])
     end
 
-    it "resolves nested columns" do
+    it 'resolves nested columns' do
       result =
         resolver.resolve_column(
-          "lead__source"
+          'lead__source'
         )
 
       expect(result[:column]).to eq(
-        "source"
+        'source'
       )
 
       expect(result[:associations]).to eq(
@@ -95,18 +106,18 @@ RSpec.describe BharatFilterEngine::AssociationResolver do
       )
     end
 
-    it "resolves multi-level columns" do
+    it 'resolves multi-level columns' do
       result =
         resolver.resolve_column(
-          "lead__client__name"
+          'lead__client__name'
         )
 
       expect(result[:column]).to eq(
-        "name"
+        'name'
       )
 
       expect(result[:associations]).to eq(
-        [:lead, :client]
+        %i[lead client]
       )
 
       expect(result[:klass]).to eq(
@@ -114,19 +125,27 @@ RSpec.describe BharatFilterEngine::AssociationResolver do
       )
     end
 
-    it "returns nil for invalid column" do
+    it 'returns nil for invalid column' do
       result =
         resolver.resolve_column(
-          "lead__invalid"
+          'lead__invalid'
         )
 
       expect(result).to be_nil
     end
-  end
 
-  describe "#join" do
+    it 'returns nil when an intermediate association is invalid' do
+      result =
+        resolver.resolve_column(
+          'lead__not_a_real_association__name'
+        )
+
+      expect(result).to be_nil
+    end
+  end
 
-    it "joins one association" do
+  describe '#join' do
+    it 'joins one association' do
       scope =
         resolver.join(
           Sale.all,
@@ -136,25 +155,25 @@ RSpec.describe BharatFilterEngine::AssociationResolver do
       expect(
         scope.to_sql
       ).to include(
-        "JOIN"
+        'JOIN'
       )
     end
 
-    it "joins nested associations" do
+    it 'joins nested associations' do
       scope =
         resolver.join(
           Sale.all,
-          [
-            :lead,
-            :client
+          %i[
+            lead
+            client
           ]
         )
 
       expect(
         scope.to_sql
       ).to include(
-        "JOIN"
+        'JOIN'
       )
     end
   end
-end
+end