bharat_filter_engine 0.2.0pre → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 811680608cacda9f967cd20ce13482ed5cbe637ce21193d6d7b4932266f15556
-  data.tar.gz: 41c8837e9ae4df42f83d5fae6a7907ed00dfb7308f72273dbe23d7e05f55ac03
+  metadata.gz: 45380eb2ba5afe790b2cbc8f0abe65cbab402d2489fb025bd2d2407c5700a57f
+  data.tar.gz: 8529dbb3f163c708c819ab166e1d946d23900ef685b9bb44b758f734c44c913b
 SHA512:
-  metadata.gz: c61055a2cb73bd87b4ddb0bc1258515ee78d1f9dbafe51ad1027165de23b054c3a5d07bb3d3b14c6df089c6d6b34f99b565bedae8a5d05eb63f7ff31bedab5e6
-  data.tar.gz: d68e184b788757dcbb8940cb2096ce85859b6a70864457f4977a3b4607316fa7d455e078624ed5f8acc39a78f458331ef4c0bb7b7f455a6d5f4de57dd01176b1
+  metadata.gz: 4ae9d8027f95b37c0f7f43235a56cc0b234ab444aa0079bfa1425b44ca408677def18f0f11216dced37321b68765a7e64fcd2217add708dc097a8da6e44c536e
+  data.tar.gz: a2ea4acb0d03be39e10d59b0c01b7da206489e95fbad43a7d60c1f04e83c9de7031de5d5779599b6c22348e684c17b326b2d9f3fa3b39a022e69b3ab429cd1be

data/Gemfile

@@ -12,6 +12,8 @@ group :development, :test do
   gem 'rake'
   gem 'rspec'
   gem 'rubocop-rails-omakase', require: false
+  gem 'rubocop-rake', require: false
+  gem 'rubocop-rspec', require: false
   gem 'sqlite3'
 end
 

data/lib/bharat_filter_engine/association_resolver.rb

@@ -8,18 +8,13 @@ module BharatFilterEngine
 
     def resolve(path)
       parts = path.to_s.split('__').map(&:to_sym)
-
       return nil if parts.empty?
 
       current_klass = @scope.klass
       reflections = []
 
       parts.each do |association_name|
-        reflection =
-          current_klass.reflect_on_association(
-            association_name
-          )
-
+        reflection = current_klass.reflect_on_association(association_name)
         return nil unless reflection
 
         reflections << reflection
@@ -36,11 +31,6 @@ module BharatFilterEngine
 
     def resolve_column(field)
       field = field.to_s
-
-      # ----------------------------------------
-      # Direct column
-      # ----------------------------------------
-
       if @scope.klass.column_names.include?(field)
         return {
           column: field,
@@ -50,41 +40,32 @@ module BharatFilterEngine
         }
       end
 
-      # ----------------------------------------
       # Nested column
-      #
       # lead__client__name
-      #
       # lead -> client -> name
-      # ----------------------------------------
-
       parts = field.split('__')
-
-      column =
-        parts.pop
-
-      association_path =
-        parts.join('__')
-
-      result =
-        resolve(association_path)
+      column = parts.pop
+      association_path = parts.join('__')
+      result = resolve(association_path)
 
       return nil unless result
+      return nil unless result[:klass].column_names.include?(column)
 
-      return nil unless
-        result[:klass].column_names.include?(column)
-
-      result.merge(
-        column: column
-      )
+      result.merge(column: column)
     end
 
     def join(scope, associations)
       return scope if associations.blank?
 
-      scope.joins(
-        build_nested_join(associations)
-      )
+      scope.joins(build_nested_join(associations))
+    end
+
+    def subquery(associations)
+      klass = @scope.klass
+      relation = klass.unscoped.joins(build_nested_join(associations))
+      relation = yield(relation) if block_given?
+
+      relation.select(klass.arel_table[klass.primary_key])
     end
 
     private

data/lib/bharat_filter_engine/column_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module BharatFilterEngine
+  module ColumnHelper
+    STRING_COLUMN_TYPES = %i[string text].freeze
+
+    module_function
+
+    def string_like?(klass, column)
+      db_column = klass&.columns_hash&.[](column.to_s)
+      db_column.nil? || STRING_COLUMN_TYPES.include?(db_column.type)
+    end
+
+    def present_predicate(arel_column, klass, column)
+      predicate = arel_column.not_eq(nil)
+      return predicate unless string_like?(klass, column)
+
+      predicate.and(arel_column.not_eq(''))
+    end
+
+    def blank_predicate(arel_column, klass, column)
+      predicate = arel_column.eq(nil)
+      return predicate unless string_like?(klass, column)
+
+      predicate.or(arel_column.eq(''))
+    end
+  end
+end

data/lib/bharat_filter_engine/dynamic_filter_values.rb

@@ -18,23 +18,10 @@ module BharatFilterEngine
       result = resolver.resolve_column(@field)
       return nil unless result
 
-      scoped =
-        resolver.join(
-          @scope,
-          result[:associations]
-        )
-
+      scoped = resolver.join(@scope, result[:associations])
       arel_column = result[:klass].arel_table[result[:column]]
-
-      scoped =
-        scoped.where(
-          arel_column.not_eq(nil).and(
-            arel_column.not_eq('')
-          )
-        )
-
+      scoped = scoped.where(ColumnHelper.present_predicate(arel_column, result[:klass], result[:column]))
       scoped = apply_term(scoped, arel_column) if @term
-
       scoped = scoped.distinct.order(arel_column)
       scoped = scoped.limit(@limit) if @limit&.positive?
 
@@ -44,12 +31,8 @@ module BharatFilterEngine
     private
 
     def apply_term(scoped, arel_column)
-      escaped =
-        @term.to_s.gsub(/[\\%_]/) { |char| "#{LIKE_ESCAPE_CHAR}#{char}" }
-
-      scoped.where(
-        arel_column.matches("%#{escaped}%", LIKE_ESCAPE_CHAR)
-      )
+      escaped = @term.to_s.gsub(/[\\%_]/) { |char| "#{LIKE_ESCAPE_CHAR}#{char}" }
+      scoped.where(arel_column.matches("%#{escaped}%", LIKE_ESCAPE_CHAR))
     end
   end
 end

data/lib/bharat_filter_engine/engine.rb

@@ -2,6 +2,7 @@
 
 module BharatFilterEngine
   class Engine
+    NUMERIC_PATTERN = /\A[+-]?\d+(\.\d+)?\z/
     class << self
       def apply(scope:, config:, params:)
         new(
@@ -56,6 +57,8 @@ module BharatFilterEngine
 
     def call
       scope = @scope
+      @tracker = JoinTracker.new(scope.klass)
+      @subquery_groups = {}
 
       @config.each do |key, raw_rule|
         value =
@@ -76,6 +79,10 @@ module BharatFilterEngine
           )
       end
 
+      @subquery_groups.each_value do |group|
+        scope = apply_subquery_group(scope, group)
+      end
+
       scope
     end
 
@@ -118,6 +125,18 @@ module BharatFilterEngine
               'in your filter config.'
       end
 
+      if @tracker.claim(result) == :subquery
+        group =
+          (@subquery_groups[result[:associations]] ||= {
+            result: result,
+            entries: []
+          })
+
+        group[:entries] << [rule, value]
+
+        return scope
+      end
+
       joined_scope =
         resolver.join(
           scope,
@@ -128,15 +147,36 @@ module BharatFilterEngine
         joined_scope,
         rule,
         value,
-        table_name: result[:table_name]
+        table_name: result[:table_name],
+        klass: result[:klass]
       ).distinct
     end
 
+    def apply_subquery_group(scope, group)
+      result = group[:result]
+
+      subquery =
+        AssociationResolver.new(scope).subquery(result[:associations]) do |relation|
+          group[:entries].reduce(relation) do |current, (rule, value)|
+            apply_filter_by_type(
+              current,
+              rule,
+              value,
+              table_name: result[:table_name],
+              klass: result[:klass]
+            )
+          end
+        end
+
+      scope.where(scope.klass.primary_key => subquery)
+    end
+
     def apply_filter_by_type(
       scope,
       rule,
       value,
-      table_name: nil
+      table_name: nil,
+      klass: nil
     )
       column =
         rule[:dbcolumn]
@@ -201,13 +241,15 @@ module BharatFilterEngine
           scope,
           column,
           value,
-          table_name
+          table_name,
+          klass: klass
         )
 
       when :search
         SearchBuilder.new(
           scope: scope,
-          allowed_columns: rule[:dbcolumns]
+          allowed_columns: rule[:dbcolumns],
+          tracker: @tracker
         ).apply(value)
 
       else
@@ -268,28 +310,20 @@ module BharatFilterEngine
       )
     end
 
-    def apply_presence_filter(scope, column, value, table_name)
+    def apply_presence_filter(scope, column, value, table_name, klass: nil)
       present = ActiveModel::Type::Boolean.new.cast(value)
-
+      klass ||= scope.klass
       arel_column =
         if table_name
           Arel::Table.new(table_name)[column]
         else
-          scope.klass.arel_table[column]
+          klass.arel_table[column]
         end
 
       if present
-        scope.where(
-          arel_column.not_eq(nil).and(
-            arel_column.not_eq('')
-          )
-        )
+        scope.where(ColumnHelper.present_predicate(arel_column, klass, column))
       else
-        scope.where(
-          arel_column.eq(nil).or(
-            arel_column.eq('')
-          )
-        )
+        scope.where(ColumnHelper.blank_predicate(arel_column, klass, column))
       end
     end
 
@@ -333,8 +367,6 @@ module BharatFilterEngine
       scope.where(Arel::Nodes::Not.new(predicate))
     end
 
-    NUMERIC_PATTERN = /\A[+-]?\d+(\.\d+)?\z/
-
     def apply_numeric_filter(
       scope,
       rule,

data/lib/bharat_filter_engine/join_tracker.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module BharatFilterEngine
+  class JoinTracker
+    def initialize(base_klass)
+      @tables = Set.new([base_klass.table_name])
+      @chains = Set.new
+      @subquery_supported = base_klass.primary_key.is_a?(String)
+    end
+
+    # Returns :join or :subquery.
+    def claim(result)
+      chain = result[:associations]
+
+      return :join if chain.blank?
+      return :join if @chains.include?(chain)
+      return :join unless @subquery_supported
+      return :subquery if @tables.include?(result[:table_name])
+
+      register(result)
+      :join
+    end
+
+    private
+
+    def register(result)
+      chain = result[:associations]
+
+      chain.each_index do |index|
+        @chains << chain[0..index]
+        @tables << result[:reflections][index].klass.table_name
+      end
+    end
+  end
+end

data/lib/bharat_filter_engine/search_builder.rb

@@ -4,8 +4,9 @@ module BharatFilterEngine
   class SearchBuilder
     LIKE_ESCAPE_CHAR = '\\'
 
-    def initialize(scope:, allowed_columns:)
+    def initialize(scope:, allowed_columns:, tracker: nil)
       @scope = scope
+      @tracker = tracker || JoinTracker.new(scope.klass)
       @allowed_columns =
         Array(allowed_columns).map(&:to_s)
 
@@ -79,6 +80,7 @@ module BharatFilterEngine
 
               next if field.blank?
               next if search_value.blank?
+              next unless @allowed_columns.include?(field)
               next unless valid_field?(field)
 
               query = like_query(search_value.strip)
@@ -132,21 +134,25 @@ 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, LIKE_ESCAPE_CHAR)
+      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}" }

data/lib/bharat_filter_engine/version.rb

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

data/lib/bharat_filter_engine.rb

@@ -8,9 +8,11 @@ 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/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

data/spec/dynamic_filter_values_spec.rb

@@ -132,6 +132,46 @@ RSpec.describe BharatFilterEngine::DynamicFilterValues do
     )
   end
 
+  it 'returns distinct values for an integer column' do
+    Sale.create!(project_id: 3)
+    Sale.create!(project_id: 1)
+    Sale.create!(project_id: 3)
+    Sale.create!(project_id: nil)
+
+    result = described_class.new(scope: Sale.all, field: 'project_id').call
+    expect(result).to eq([1, 3])
+  end
+
+  it 'keeps a zero value for a numeric column' do
+    Sale.create!(amount: 0)
+    Sale.create!(amount: 5)
+
+    result = described_class.new(scope: Sale.all, field: 'amount').call
+    expect(result).to eq([0, 5])
+  end
+
+  it 'returns distinct values for a datetime column' do
+    Sale.create!(actual_sale_date: Time.utc(2013, 1, 1))
+    Sale.create!(actual_sale_date: nil)
+
+    result = described_class.new(scope: Sale.all, field: 'actual_sale_date').call
+    expect(result.size).to eq(1)
+  end
+
+  it 'returns distinct values for a nested integer column' do
+    client = Client.create!(name: 'Nested Co')
+    lead = Lead.create!(source: 'web', client: client)
+    Sale.create!(lead: lead)
+    Sale.create!(lead: lead)
+    Sale.create!(lead: nil)
+
+    result = described_class.new(scope: Sale.all, field: 'lead__client_id').call
+    expected = Sale.joins(:lead).distinct.pluck('leads.client_id').compact.sort
+
+    expect(result).to include(client.id)
+    expect(result).to eq(expected)
+  end
+
   it 'filters values by a partial term' do
     Sale.create!(stage: 'closed')
 

data/spec/engine_spec.rb

@@ -1356,6 +1356,78 @@ RSpec.describe BharatFilterEngine::Engine do
         expect(result).to contain_exactly(sale_with_org)
       end
     end
+
+    describe 'presence filter on non-string columns' do
+      def presence_config(column, **extra)
+        { has_value: { type: :single, filter_type: :presence, dbcolumn: column }.merge(extra) }
+      end
+
+      {
+        project_id: [1, 7],
+        amount: [0, 500],
+        conversion_rate: [0.0, 2.5],
+        actual_sale_date: [Time.utc(2013, 1, 1), Time.utc(2013, 6, 1)],
+        active: [false, true]
+      }.each do |column, (value_one, value_two)|
+        context "on the #{column} column" do
+          let!(:with_one) { Sale.create!(column => value_one) }
+          let!(:with_two) { Sale.create!(column => value_two) }
+          let!(:without)  { Sale.create!(column => nil) }
+
+          it 'returns only non-NULL rows when value is true' do
+            result = described_class.apply(
+              scope: Sale.all, config: presence_config(column), params: { has_value: 'true' }
+            )
+            expect(result).to contain_exactly(with_one, with_two)
+          end
+
+          it 'returns only NULL rows when value is false' do
+            result = described_class.apply(
+              scope: Sale.all, config: presence_config(column), params: { has_value: 'false' }
+            )
+            expect(result).to contain_exactly(without)
+          end
+        end
+      end
+
+      it 'treats a zero integer as present, not blank' do
+        zero = Sale.create!(amount: 0)
+        Sale.create!(amount: nil)
+
+        result = described_class.apply(
+          scope: Sale.all, config: presence_config(:amount), params: { has_value: 'true' }
+        )
+        expect(result).to contain_exactly(zero)
+      end
+
+      it 'works on a nested non-string (integer foreign key) column' do
+        client = Client.create!(name: 'John')
+        lead_with_client = Lead.create!(source: 'google', client: client)
+        lead_without_client = Lead.create!(source: 'referral', client: nil)
+        sale_with = Sale.create!(lead: lead_with_client)
+        sale_without = Sale.create!(lead: lead_without_client)
+
+        config = {
+          has_client: { type: :nested, filter_type: :presence, association: :lead, dbcolumn: :client_id }
+        }
+        present = described_class.apply(scope: Sale.all, config: config, params: { has_client: 'true' })
+        blank   = described_class.apply(scope: Sale.all, config: config, params: { has_client: 'false' })
+
+        expect(present).to contain_exactly(sale_with)
+        expect(blank).to contain_exactly(sale_without)
+      end
+
+      it 'still treats an empty string as blank on a string column' do
+        sale = Sale.create!(stage: 'qualified')
+        Sale.create!(stage: '')
+
+        result = described_class.apply(
+          scope: Sale.all, config: presence_config(:stage), params: { has_value: true }
+        )
+        expect(result).to contain_exactly(sale)
+      end
+    end
+
     describe 'invalid numeric input' do
       it 'ignores a non-numeric exact integer filter value' do
         sale = Sale.create!(amount: 500)

data/spec/join_tracker_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe BharatFilterEngine::JoinTracker do
+  subject(:tracker) { described_class.new(Lead) }
+
+  let(:resolver) { BharatFilterEngine::AssociationResolver.new(Lead.all) }
+
+  def resolve(path)
+    resolver.resolve(path)
+  end
+
+  it 'lets the first path to a table use a plain join' do
+    expect(tracker.claim(resolve(:client))).to eq(:join)
+  end
+
+  it 'reuses the join when exactly the same path is claimed again' do
+    tracker.claim(resolve(:client))
+
+    expect(tracker.claim(resolve(:client))).to eq(:join)
+  end
+
+  it 'moves a different path to an already-used table into a subquery' do
+    tracker.claim(resolve(:client))
+
+    expect(tracker.claim(resolve(:referrer))).to eq(:subquery)
+  end
+
+  it 'keeps answering :subquery for that second path' do
+    tracker.claim(resolve(:client))
+    tracker.claim(resolve(:referrer))
+
+    expect(tracker.claim(resolve(:referrer))).to eq(:subquery)
+  end
+
+  it 'joins paths that end in different tables' do
+    expect(tracker.claim(resolve(:client))).to eq(:join)
+    expect(tracker.claim(resolve(:client__organization))).to eq(:join)
+  end
+
+  it 'shares a prefix that an earlier, longer path already joined' do
+    tracker.claim(resolve(:client__organization))
+
+    expect(tracker.claim(resolve(:client))).to eq(:join)
+  end
+
+  it 'detects collisions at the end of multi-level paths' do
+    tracker.claim(resolve(:client__organization))
+
+    expect(tracker.claim(resolve(:referrer__organization))).to eq(:subquery)
+  end
+
+  it 'sends a path that returns to the base table to a subquery' do
+    expect(tracker.claim(resolve(:client__leads))).to eq(:subquery)
+  end
+
+  it 'always joins when there is no association path' do
+    expect(tracker.claim(associations: [], table_name: 'leads')).to eq(:join)
+  end
+
+  it 'falls back to joins for composite primary keys' do
+    klass = double('composite_pk_model', table_name: 'leads', primary_key: %w[a b])
+    composite = described_class.new(klass)
+
+    composite.claim(resolve(:client))
+
+    expect(composite.claim(resolve(:referrer))).to eq(:join)
+  end
+end

data/spec/same_table_join_spec.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# Two different associations that point at the SAME table (Lead#client and
+# Lead#referrer are both `clients`). ActiveRecord aliases the second join, so
+# conditions written against the plain table name used to hit the wrong join.
+RSpec.describe 'filters through two associations to the same table' do
+  def nested(association, filter_type, column, **extra)
+    { type: :nested, association: association, filter_type: filter_type, dbcolumn: column }.merge(extra)
+  end
+
+  def search(columns)
+    { type: :single, filter_type: :search, dbcolumns: columns }
+  end
+
+  let!(:acme)   { Organization.create!(name: 'Acme') }
+  let!(:globex) { Organization.create!(name: 'Globex') }
+
+  let!(:alice) { Client.create!(name: 'Alice', email: 'alice@x.com', organization: acme) }
+  let!(:bob)   { Client.create!(name: 'Bob', email: 'bob@x.com', organization: globex) }
+
+  let!(:alice_bob)   { Lead.create!(source: 'google', client: alice, referrer: bob) }
+  let!(:bob_alice)   { Lead.create!(source: 'google', client: bob, referrer: alice) }
+  let!(:alice_alice) { Lead.create!(source: 'google', client: alice, referrer: alice) }
+  let!(:alice_none)  { Lead.create!(source: 'google', client: alice, referrer: nil) }
+
+  let(:both_names) do
+    {
+      client_name: nested(:client, :string, :name),
+      referrer_name: nested(:referrer, :string, :name)
+    }
+  end
+
+  def apply(config, scope: Lead.all, **params)
+    BharatFilterEngine::Engine.apply(scope: scope, config: config, params: params)
+  end
+
+  describe 'nested filters' do
+    it 'applies each condition to its own association' do
+      expect(apply(both_names, client_name: 'Alice', referrer_name: 'Bob')).to contain_exactly(alice_bob)
+      expect(apply(both_names, client_name: 'Bob', referrer_name: 'Alice')).to contain_exactly(bob_alice)
+    end
+
+    it 'allows both associations to match the same record' do
+      expect(apply(both_names, client_name: 'Alice', referrer_name: 'Alice')).to contain_exactly(alice_alice)
+    end
+
+    it 'does not depend on the order of the config' do
+      reversed = both_names.to_a.reverse.to_h
+
+      expect(apply(reversed, client_name: 'Alice', referrer_name: 'Bob')).to contain_exactly(alice_bob)
+    end
+
+    it 'returns nothing when no record matches both conditions' do
+      expect(apply(both_names, client_name: 'Bob', referrer_name: 'Bob')).to be_empty
+    end
+
+    it 'supports a negated filter on the second association' do
+      config = {
+        client_name: nested(:client, :string, :name),
+        referrer_name: nested(:referrer, :string, :name, negate: true)
+      }
+
+      expect(apply(config, client_name: 'Alice', referrer_name: 'Bob')).to contain_exactly(alice_alice)
+    end
+
+    it 'works across multi-level paths that end in the same table' do
+      config = {
+        client_org: nested(:client__organization, :string, :name),
+        referrer_org: nested(:referrer__organization, :string, :name)
+      }
+
+      expect(apply(config, client_org: 'Acme', referrer_org: 'Globex')).to contain_exactly(alice_bob)
+      expect(apply(config, client_org: 'Globex', referrer_org: 'Acme')).to contain_exactly(bob_alice)
+    end
+
+    it 'works through a has_many-free parent (Sale -> lead -> client/referrer)' do
+      Sale.create!(lead: alice_bob, stage: 'won')
+      Sale.create!(lead: bob_alice, stage: 'won')
+
+      sale_config = {
+        client_name: nested(:lead__client, :string, :name),
+        referrer_name: nested(:lead__referrer, :string, :name)
+      }
+      sales = apply(sale_config, scope: Sale.all, client_name: 'Alice', referrer_name: 'Bob')
+      expect(sales.map(&:lead)).to contain_exactly(alice_bob)
+    end
+
+    it 'returns a normal relation that can be counted, ordered and limited' do
+      relation = apply(both_names, client_name: 'Alice', referrer_name: 'Bob')
+
+      expect(relation).to be_a(ActiveRecord::Relation)
+      expect(relation.count).to eq(1)
+      expect(relation.exists?).to be(true)
+      expect(relation.order(:id).limit(1).pluck(:id)).to eq([alice_bob.id])
+    end
+  end
+
+  describe 'search' do
+    it 'searches both associations with OR semantics' do
+      result = apply({ q: search(%i[client__name referrer__name]) }, q: 'Bob')
+
+      expect(result).to contain_exactly(alice_bob, bob_alice)
+    end
+
+    it 'supports field=value search on both associations (AND)' do
+      result = apply({ q: search(%i[client__name referrer__name]) }, q: 'client__name=Alice&referrer__name=Bob')
+
+      expect(result).to contain_exactly(alice_bob)
+    end
+
+    it 'works when SearchBuilder is used on its own (no engine)' do
+      builder = BharatFilterEngine::SearchBuilder.new(scope: Lead.all, allowed_columns: %w[client__name referrer__name])
+
+      expect(builder.apply('Bob')).to contain_exactly(alice_bob, bob_alice)
+    end
+  end
+
+  describe 'nested filter combined with search' do
+    let(:nested_then_search) do
+      { referrer_name: nested(:referrer, :string, :name), q: search(%i[client__name]) }
+    end
+
+    it 'is correct when the nested filter comes first' do
+      expect(apply(nested_then_search, referrer_name: 'Bob', q: 'alice')).to contain_exactly(alice_bob)
+    end
+
+    it 'is correct when the search comes first' do
+      search_then_nested = nested_then_search.to_a.reverse.to_h
+
+      expect(apply(search_then_nested, referrer_name: 'Bob', q: 'alice')).to contain_exactly(alice_bob)
+    end
+  end
+
+  describe 'has_many paths to the same table' do
+    let!(:dave) { Client.create!(name: 'Dave') }
+    let!(:carol) { Client.create!(name: 'Carol') }
+
+    before do
+      # alice: a google lead; referred leads won/referral and lost/web (DIFFERENT rows)
+      # bob:   a google lead; referred lead won/web (ONE row satisfies both)
+      # carol: no google lead; referred lead won/web
+      Lead.where(client: [alice, bob, carol]).delete_all
+      Lead.create!(source: 'google', client: alice)
+      Lead.create!(source: 'google', client: bob)
+      Lead.create!(source: 'referral', client: carol)
+      Lead.create!(source: 'referral', status: 'won', client: dave, referrer: alice)
+      Lead.create!(source: 'web', status: 'lost', client: dave, referrer: alice)
+      Lead.create!(source: 'web', status: 'won', client: dave, referrer: bob)
+      Lead.create!(source: 'web', status: 'won', client: dave, referrer: carol)
+    end
+
+    let(:config) do
+      {
+        own_source: nested(:leads, :string, :source),
+        ref_status: nested(:referred_leads, :string, :status),
+        ref_source: nested(:referred_leads, :string, :source)
+      }
+    end
+
+    it 'works when two has_many associations point at the same table' do
+      result = apply(config.slice(:own_source, :ref_status), scope: Client.all, own_source: 'google', ref_status: 'won')
+
+      expect(result).to contain_exactly(alice, bob)
+    end
+
+    it 'keeps conditions on one path matching the SAME joined row' do
+      result = apply(config, scope: Client.all, own_source: 'google', ref_status: 'won', ref_source: 'web')
+
+      expect(result).to contain_exactly(bob)
+    end
+  end
+
+  describe 'SQL for cases that never collided' do
+    it 'keeps a single nested filter as a plain DISTINCT join' do
+      sql = apply({ c: nested(:client, :string, :name) }, c: 'Alice').to_sql
+
+      expect(sql.scan('INNER JOIN').size).to eq(1)
+      expect(sql).to include('DISTINCT')
+      expect(sql).not_to include('IN (SELECT')
+    end
+
+    it 'shares one join when two filters use the same path' do
+      config = { n: nested(:client, :string, :name), e: nested(:client, :string, :email) }
+      sql = apply(config, n: 'Alice', e: 'alice@x.com').to_sql
+
+      expect(sql.scan('INNER JOIN').size).to eq(1)
+      expect(sql).not_to include('IN (SELECT')
+    end
+
+    it 'does not use a subquery for joins to different tables' do
+      config = { c: nested(:client, :string, :name), o: nested(:client__organization, :string, :name) }
+      sql = apply(config, c: 'Alice', o: 'Acme').to_sql
+
+      expect(sql).not_to include('IN (SELECT')
+    end
+  end
+end

data/spec/search_builder_spec.rb

@@ -93,6 +93,27 @@ RSpec.describe BharatFilterEngine::SearchBuilder do
     expect(result).to contain_exactly(sale_two)
   end
 
+  it 'returns each record once when searching through a has_many association' do
+    matching_client = Client.create!(name: 'John1')
+    Lead.create!(source: 'google', client: matching_client)
+    Lead.create!(source: 'google', client: matching_client)
+    Client.create!(name: 'John2').tap do |other_client|
+      Lead.create!(source: 'meta', client: other_client)
+    end
+
+    result =
+      described_class.new(
+        scope: Client.all,
+        allowed_columns: [:leads__source]
+      ).apply(
+        'leads__source=google'
+      )
+
+    expect(result).to contain_exactly(client, matching_client)
+    expect(result.count).to eq(2)
+    expect(result.order(:id).limit(1).pluck(:id)).to eq([client.id])
+  end
+
   it 'supports OR search' do
     result =
       described_class.new(
@@ -153,6 +174,30 @@ RSpec.describe BharatFilterEngine::SearchBuilder do
     expect(result).to be_empty
   end
 
+  it 'returns no records when the searched model column is not allowed' do
+    result =
+      described_class.new(
+        scope: Sale.all,
+        allowed_columns: [:stage]
+      ).apply(
+        'approval_status=approved'
+      )
+
+    expect(result).to be_empty
+  end
+
+  it 'returns no records when the searched association column is not allowed' do
+    result =
+      described_class.new(
+        scope: Sale.all,
+        allowed_columns: [:stage]
+      ).apply(
+        'lead__client__email=john@example.com'
+      )
+
+    expect(result).to be_empty
+  end
+
   it 'supports searching the id column as text' do
     result =
       described_class.new(

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'logger'
 require 'bundler/setup'
 require 'active_record'
 require 'database_cleaner/active_record'
@@ -26,6 +27,7 @@ ActiveRecord::Schema.define do
     t.string :source
     t.string :status
     t.references :client
+    t.integer :referrer_id
     t.datetime :created_at
   end
 
@@ -48,10 +50,12 @@ end
 class Client < ActiveRecord::Base
   belongs_to :organization
   has_many :leads
+  has_many :referred_leads, class_name: 'Lead', foreign_key: :referrer_id
 end
 
 class Lead < ActiveRecord::Base
   belongs_to :client
+  belongs_to :referrer, class_name: 'Client', optional: true
   has_many :sales
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bharat_filter_engine
 version: !ruby/object:Gem::Version
-  version: 0.2.0pre
+  version: 0.2.0
 platform: ruby
 authors:
 - Jayesh Rathore
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-25 00:00:00.000000000 Z
+date: 2026-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -69,16 +69,20 @@ files:
 - Rakefile
 - lib/bharat_filter_engine.rb
 - lib/bharat_filter_engine/association_resolver.rb
+- lib/bharat_filter_engine/column_helper.rb
 - lib/bharat_filter_engine/dynamic_filter_values.rb
 - lib/bharat_filter_engine/engine.rb
 - lib/bharat_filter_engine/errors.rb
+- lib/bharat_filter_engine/join_tracker.rb
 - lib/bharat_filter_engine/rule_normalizer.rb
 - lib/bharat_filter_engine/search_builder.rb
 - lib/bharat_filter_engine/version.rb
 - spec/association_resolver_spec.rb
 - spec/dynamic_filter_values_spec.rb
 - spec/engine_spec.rb
+- spec/join_tracker_spec.rb
 - spec/rule_normalizer_spec.rb
+- spec/same_table_join_spec.rb
 - spec/search_builder_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/jayesh70240/bharat-filter-engine
@@ -89,6 +93,7 @@ metadata:
   source_code_uri: https://github.com/jayesh70240/bharat-filter-engine
   changelog_uri: https://github.com/jayesh70240/bharat-filter-engine/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/jayesh70240/bharat-filter-engine/issues
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -104,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: A generic filtering engine for Rails ActiveRecord