forest_liana 9.20.11 → 9.20.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a13f2892e518d41f6c0aae28e4f14397086cd58f19b25c4b1fa86b4fefeaf911
-  data.tar.gz: 76853d12f9eddbf87235f2a407814d3e23938a35f51c1e77a33f99ccdee0a5e7
+  metadata.gz: 113a6c37672221a6fb2b94fb001ae0c04101b239e4b1eb6c8046d3c4485da005
+  data.tar.gz: 928f89e4c0bfa3c5cb925b64ae437caf73aed141f704fafec4464da49d9a5a09
 SHA512:
-  metadata.gz: ff3de870bcc72b16398b83be65bc2fb363b5274f17138fdd63532b93b34a38c1ed5959514642c16fad12a31c1040ed63039f614ec24e24281076049869d853a6
-  data.tar.gz: fe52ff22910b5e3d701de07cc26c60036c67ab735a2945cde9a0c2f76739b1a3c13062eaa4b6dcab7306a3968906914db707fac023ade714783e69d006fb4df3
+  metadata.gz: 07b02e0de1972b2ce1fba69415e2719695eebd0ab69791f34270873667916088a87d214824520b6a26ddf21b6af7dadff2defa69c712f79e1258ac3d6a5e4dcf
+  data.tar.gz: 6e71fa92203f7ad24a9c5e581b3c57789c479cfd94651040a9078bf075358ddc53256dad73ce4453b14f282fdad5f895bd8bf124167386c4bf50ef0b9f221aac

data/app/services/forest_liana/base_getter.rb

@@ -24,6 +24,14 @@ module ForestLiana
       @optional_includes = []
     end
 
+    # A search predicate can only name an association the eager load actually joins;
+    # analyze_associations drops the rest, leaving their table out of the FROM clause.
+    def searchable_includes(resource)
+      polymorphic, preload_loads = analyze_associations(resource)
+
+      (@includes - polymorphic - preload_loads).map(&:to_sym)
+    end
+
     def optimize_record_loading(resource, records, force_preload = true)
       polymorphic, preload_loads = analyze_associations(resource)
       result = records.eager_load(@includes.uniq - preload_loads - polymorphic - @optional_includes)

data/app/services/forest_liana/has_many_getter.rb

@@ -14,8 +14,7 @@ module ForestLiana
       @field_names_requested = field_names_requested
       @collection = get_collection(@collection_name)
       compute_includes()
-      includes_symbols = @includes.map { |include| include.to_sym }
-      @search_query_builder = SearchQueryBuilder.new(@params, includes_symbols, @collection, forest_user)
+      @search_query_builder = SearchQueryBuilder.new(@params, searchable_includes(model_association), @collection, forest_user)
 
       prepare_query()
     end
@@ -58,6 +57,12 @@ module ForestLiana
       @records.limit(limit).offset(offset)
     end
 
+    def includes_for_serialization
+      return super if @field_names_requested.empty?
+
+      super & @field_names_requested.map(&:to_s)
+    end
+
     private
 
     def compute_includes
@@ -76,7 +81,7 @@ module ForestLiana
             inclusion = SchemaUtils.model_included?(association.klass)
           end
 
-          if @field_names_requested.any?
+          if @field_names_requested.any? && !search_extended?
             inclusion && @field_names_requested.include?(association.name)
           else
             inclusion
@@ -84,6 +89,12 @@ module ForestLiana
         end.map(&:name)
     end
 
+    # Extended search reaches the associated tables, so its footprint must not depend
+    # on the projection: a count carries none, and would otherwise search more than the list.
+    def search_extended?
+      @params['searchExtended'].to_i == 1
+    end
+
     def field_names_requested
       fields = @params.dig(:fields, @collection_name)
       Array(fields&.split(',')).map(&:to_sym)

data/app/services/forest_liana/resources_getter.rb

@@ -6,14 +6,14 @@ module ForestLiana
       @resource = resource
       @params = params
       @user = forest_user
-      @count_needs_includes = false
+      @count_needs_includes = !@params[:search].nil?
       @collection_name = ForestLiana.name_for(@resource)
       @collection = get_collection(@collection_name)
       @fields_to_serialize = get_fields_to_serialize
       @field_names_requested = field_names_requested
       @segment = get_segment
       compute_includes
-      @search_query_builder = SearchQueryBuilder.new(@params, @includes, @collection, @user)
+      @search_query_builder = SearchQueryBuilder.new(@params, searchable_includes(@resource), @collection, @user)
 
       prepare_query
       @base_records_for_batch = @records
@@ -177,8 +177,6 @@ module ForestLiana
         end
       end
 
-      @count_needs_includes = true if @params[:search]
-
       associations.uniq
     end
 

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "9.20.11"
+  VERSION = "9.20.12"
 end

data/spec/requests/count_spec.rb

@@ -130,3 +130,246 @@ describe 'Requesting Owner', :type => :request  do
     end
   end
 end
+
+describe 'Requesting Tree count with extended search', :type => :request do
+  let(:scope_filters) { { 'scopes' => {}, 'team' => { 'id' => '1', 'name' => 'Operations' } } }
+
+  # NOTICE: `Kiwi Tree` matches the search on its own column, `Lemon Tree` matches
+  #         only through `owner.name`, and `Apple Tree` matches nothing. Extended
+  #         search must therefore return 2 records, plain search 1.
+  before(:each) do
+    Tree.destroy_all
+    Location.destroy_all
+    Island.destroy_all
+    User.destroy_all
+
+    michel = User.create(name: 'Michel')
+    kiwi_grower = User.create(name: 'Kiwi Grower')
+    @island = Island.create(name: 'Home Island')
+
+    Tree.create(name: 'Kiwi Tree', owner: michel, cutter: michel, island: @island)
+    Tree.create(name: 'Lemon Tree', owner: kiwi_grower, cutter: michel, island: @island)
+    Tree.create(name: 'Apple Tree', owner: michel, cutter: michel, island: @island)
+
+    allow(ForestLiana::IpWhitelist).to receive(:retrieve) { true }
+    allow(ForestLiana::IpWhitelist).to receive(:is_ip_whitelist_retrieved) { true }
+    allow(ForestLiana::IpWhitelist).to receive(:is_ip_valid) { true }
+
+    allow_any_instance_of(ForestLiana::Ability).to receive(:forest_authorize!) { true }
+
+    allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return(scope_filters)
+  end
+
+  after(:each) do
+    Tree.destroy_all
+    Location.destroy_all
+    Island.destroy_all
+    User.destroy_all
+  end
+
+  token = JWT.encode({
+                       id: 38,
+                       email: 'michael.kelso@that70.show',
+                       first_name: 'Michael',
+                       last_name: 'Kelso',
+                       team: 'Operations',
+                       rendering_id: 16,
+                       exp: Time.now.to_i + 2.weeks.to_i,
+                       permission_level: 'admin'
+                     }, ForestLiana.auth_secret, 'HS256')
+
+  headers = {
+    'Accept' => 'application/json',
+    'Content-Type' => 'application/json',
+    'Authorization' => "Bearer #{token}"
+  }
+
+  def count_returned
+    JSON.parse(response.body)['count']
+  end
+
+  def records_returned
+    JSON.parse(response.body)['data'].size
+  end
+
+  describe 'count' do
+    let(:projection) { { 'Tree' => 'id,name,owner' } }
+    let(:params) {
+      {
+        page: { 'number' => '1', 'size' => '10' },
+        search: 'kiwi',
+        searchExtended: '1',
+        timezone: 'Europe/Paris'
+      }
+    }
+
+    describe 'when the request carries no fields' do
+      it 'responds 200 with the number of records the list returns for the same search' do
+        get '/forest/Tree', params: params, headers: headers
+        listed = records_returned
+
+        get '/forest/Tree/count', params: params, headers: headers
+
+        expect(response.status).to eq(200)
+        expect(count_returned).to eq(2)
+        expect(count_returned).to eq(listed)
+      end
+    end
+
+    describe 'when the request carries fields' do
+      it 'responds 200 with the number of records the list returns for the same search' do
+        get '/forest/Tree', params: params.merge(fields: projection), headers: headers
+        listed = records_returned
+
+        get '/forest/Tree/count', params: params.merge(fields: projection), headers: headers
+
+        expect(response.status).to eq(200)
+        expect(count_returned).to eq(2)
+        expect(count_returned).to eq(listed)
+      end
+    end
+
+    describe 'when the same count is requested twice' do
+      it 'returns the same count both times' do
+        get '/forest/Tree/count', params: params, headers: headers
+        first_count = count_returned
+
+        get '/forest/Tree/count', params: params, headers: headers
+
+        expect(response.status).to eq(200)
+        expect(count_returned).to eq(2)
+        expect(count_returned).to eq(first_count)
+      end
+    end
+
+    describe 'when extended search is off' do
+      it 'counts only the records matching on their own columns' do
+        get '/forest/Tree', params: params.merge(searchExtended: '0'), headers: headers
+        listed = records_returned
+
+        get '/forest/Tree/count', params: params.merge(searchExtended: '0'), headers: headers
+
+        expect(response.status).to eq(200)
+        expect(count_returned).to eq(1)
+        expect(count_returned).to eq(listed)
+      end
+    end
+
+    describe 'when searchExtended is absent from the request' do
+      it 'counts only the records matching on their own columns' do
+        get '/forest/Tree/count', params: params.except(:searchExtended), headers: headers
+
+        expect(response.status).to eq(200)
+        expect(count_returned).to eq(1)
+      end
+    end
+
+    describe 'when the search matches no record at all' do
+      it 'responds 200 with a count of zero' do
+        get '/forest/Tree', params: params.merge(search: 'sequoia'), headers: headers
+        listed = records_returned
+
+        get '/forest/Tree/count', params: params.merge(search: 'sequoia'), headers: headers
+
+        expect(response.status).to eq(200)
+        expect(count_returned).to eq(0)
+        expect(count_returned).to eq(listed)
+      end
+    end
+
+    describe 'when the search is an empty string' do
+      it 'counts every record' do
+        get '/forest/Tree/count', params: params.merge(search: ''), headers: headers
+
+        expect(response.status).to eq(200)
+        expect(count_returned).to eq(3)
+      end
+    end
+
+    describe 'when the request carries no search at all' do
+      it 'counts every record' do
+        get '/forest/Tree/count', params: params.except(:search), headers: headers
+
+        expect(response.status).to eq(200)
+        expect(count_returned).to eq(3)
+      end
+    end
+  end
+
+  describe 'count on relationships' do
+    let(:projection) { { 'Tree' => 'id,name' } }
+    let(:params) {
+      {
+        page: { 'number' => '1', 'size' => '10' },
+        search: 'kiwi',
+        searchExtended: '1',
+        timezone: 'Europe/Paris'
+      }
+    }
+
+    describe 'when the count carries no fields and the list carries the projection' do
+      it 'counts the number of records the related list returns' do
+        get "/forest/Island/#{@island.id}/relationships/trees",
+            params: params.merge(fields: projection), headers: headers
+        listed = records_returned
+
+        get "/forest/Island/#{@island.id}/relationships/trees/count", params: params, headers: headers
+
+        expect(response.status).to eq(200)
+        expect(count_returned).to eq(2)
+        expect(count_returned).to eq(listed)
+      end
+    end
+
+    describe 'when both the count and the list carry the projection' do
+      it 'counts the number of records the related list returns' do
+        get "/forest/Island/#{@island.id}/relationships/trees",
+            params: params.merge(fields: projection), headers: headers
+        listed = records_returned
+
+        get "/forest/Island/#{@island.id}/relationships/trees/count",
+            params: params.merge(fields: projection), headers: headers
+
+        expect(response.status).to eq(200)
+        expect(count_returned).to eq(2)
+        expect(count_returned).to eq(listed)
+      end
+    end
+
+    describe 'when extended search is off' do
+      it 'counts only the related records matching on their own columns' do
+        get "/forest/Island/#{@island.id}/relationships/trees",
+            params: params.merge(searchExtended: '0', fields: projection), headers: headers
+        listed = records_returned
+
+        get "/forest/Island/#{@island.id}/relationships/trees/count",
+            params: params.merge(searchExtended: '0'), headers: headers
+
+        expect(response.status).to eq(200)
+        expect(count_returned).to eq(1)
+        expect(count_returned).to eq(listed)
+      end
+    end
+
+    describe 'when the related search matches no record at all' do
+      it 'responds 200 with a count of zero' do
+        get "/forest/Island/#{@island.id}/relationships/trees/count",
+            params: params.merge(search: 'sequoia'), headers: headers
+
+        expect(response.status).to eq(200)
+        expect(count_returned).to eq(0)
+      end
+    end
+
+    describe 'when the parent record has no related record' do
+      it 'responds 200 with a count of zero' do
+        empty_island = Island.create(name: 'Empty Island')
+
+        get "/forest/Island/#{empty_island.id}/relationships/trees/count", params: params, headers: headers
+
+        expect(response.status).to eq(200)
+        expect(count_returned).to eq(0)
+      end
+    end
+  end
+end

data/spec/services/forest_liana/has_many_getter_spec.rb

@@ -114,6 +114,145 @@ module ForestLiana
         end
       end
 
+      describe 'when searching with extended search' do
+        # HashWithIndifferentAccess: the code reads @params['searchExtended'] (string),
+        # as the controller hands it an ActionController::Parameters.
+        let(:projection) { nil }
+        let(:searchExtended) { '1' }
+        let(:params) {
+          ActiveSupport::HashWithIndifferentAccess.new(
+            id: Island.first.id,
+            association_name: 'trees',
+            search: 'kiwi',
+            searchExtended: searchExtended,
+            fields: projection,
+            page: { size: 15, number: 1 },
+            timezone: 'America/Nome'
+          )
+        }
+
+        # NOTICE: `kiwi tree` matches on its own name and `coconut tree` matches only
+        #         through `owner.name`, so extended search matches 2 of madagascar's
+        #         trees where plain search matches 1.
+        before(:each) do
+          kiwi_grower = User.create(name: 'Kiwi Grower')
+          Tree.create(name: 'kiwi tree', island: Island.first)
+          Tree.create(name: 'coconut tree', island: Island.first, owner: kiwi_grower)
+        end
+
+        after(:each) do
+          User.destroy_all
+        end
+
+        describe 'when the request carries no fields' do
+          it 'counts the related records it returns' do
+            subject.perform
+
+            expect(subject.count).to eq 2
+            expect(subject.records.count).to eq 2
+          end
+        end
+
+        describe 'when the request carries fields' do
+          let(:projection) { { 'Tree' => 'id,name' } }
+
+          it 'counts the same related records as the request carrying no fields' do
+            subject.perform
+
+            expect(subject.count).to eq 2
+            expect(subject.records.count).to eq 2
+          end
+        end
+
+        describe 'when the count carries no fields and the list carries the projection' do
+          it 'announces the number of related records the list returns' do
+            listed = described_class.new(
+              Island,
+              association,
+              params.merge(fields: { 'Tree' => 'id,name' }),
+              user
+            )
+            listed.perform
+
+            expect(subject.count).to eq 2
+            expect(listed.records.count).to eq 2
+          end
+        end
+
+        describe 'when extended search is off' do
+          let(:searchExtended) { '0' }
+
+          it 'counts only the related records matching on their own columns' do
+            subject.perform
+
+            expect(subject.count).to eq 1
+            expect(subject.records.count).to eq 1
+          end
+        end
+
+        describe 'serializing the related records' do
+          let(:projection) { { 'Tree' => 'id,name,owner' } }
+
+          it 'serializes only the associations the projection asked for' do
+            expect(subject.includes_for_serialization).to eq ['owner']
+          end
+        end
+
+        describe 'serializing the related records when no projection was requested' do
+          it 'serializes every association the search reaches' do
+            expect(subject.includes_for_serialization)
+              .to match_array(%w[owner cutter island eponymous_island location])
+          end
+        end
+      end
+
+      describe 'when the related collection has an association in another database' do
+        let(:association) { Manufacturer.reflect_on_association(:products) }
+        let(:search) { 'zzz' }
+        let(:params) {
+          ActiveSupport::HashWithIndifferentAccess.new(
+            id: Manufacturer.first.id,
+            association_name: 'products',
+            search: search,
+            searchExtended: '1',
+            fields: { 'Product' => 'id,name' },
+            page: { size: 15, number: 1 },
+            timezone: 'America/Nome'
+          )
+        }
+
+        subject { described_class.new(Manufacturer, association, params, user) }
+
+        before(:each) do
+          manufacturer = Manufacturer.create!(name: 'Acme')
+          driver = Driver.create!(firstname: 'Zed')
+          Product.create!(
+            name: 'Widget', uri: 'https://widget.example',
+            manufacturer: manufacturer, driver: driver
+          )
+        end
+
+        after(:each) do
+          Product.destroy_all
+          Manufacturer.destroy_all
+          Driver.destroy_all
+        end
+
+        it 'does not search columns the eager load cannot join' do
+          expect(subject.count).to eq 0
+          expect(subject.records.count).to eq 0
+        end
+
+        describe 'when the search matches an association in the same database' do
+          let(:search) { 'acme' }
+
+          it 'still matches through that association' do
+            expect(subject.count).to eq 1
+            expect(subject.records.count).to eq 1
+          end
+        end
+      end
+
       describe 'compute_includes' do
         it 'should include has_one relation from association' do
           expect(subject.includes).to include(:location)
@@ -154,6 +293,21 @@ module ForestLiana
           expect(subject.includes).to be_empty
         end
 
+        it 'should not narrow the includes by the requested fields when extended search is on' do
+          extended_params = ActiveSupport::HashWithIndifferentAccess.new(
+            id: Island.first.id,
+            association_name: 'trees',
+            search: 'kiwi',
+            searchExtended: '1',
+            fields: { 'Tree' => 'owner,island' },
+            page: { size: 15, number: 1 },
+            timezone: 'America/Nome'
+          )
+          getter = described_class.new(Island, association, extended_params, user)
+
+          expect(getter.includes).to match_array(%i[owner cutter island eponymous_island location])
+        end
+
         context 'on polymorphic associations' do
           let(:base_params) do
             {

data/spec/services/forest_liana/resources_getter_spec.rb

@@ -628,5 +628,111 @@ module ForestLiana
         end
       end
     end
+
+    describe 'when searching with extended search' do
+      let(:resource) { Tree }
+      let(:search) { 'skull' }
+      let(:searchExtended) { '1' }
+      let(:requested_fields) { nil }
+
+      # HashWithIndifferentAccess: the code reads @params['searchExtended'] (string),
+      # as the controller hands it an ActionController::Parameters.
+      let(:search_params) {
+        ActiveSupport::HashWithIndifferentAccess.new(
+          page: { size: pageSize, number: pageNumber },
+          search: search,
+          searchExtended: searchExtended,
+          fields: requested_fields,
+          timezone: 'Europe/Paris',
+        )
+      }
+
+      # NOTICE: the count route builds a getter and calls #count on it without ever
+      #         calling #perform, so the list getter has to be a separate instance —
+      #         #perform rewrites @records with the eager loads and would hide the defect.
+      let(:getter) { described_class.new(resource, search_params, user) }
+      let(:list_getter) { described_class.new(resource, search_params, user) }
+
+      # NOTICE: `Lemon Tree` and `Ginger Tree` both grow on the island `Skull`, and no
+      #         tree carries `skull` in its own name — so extended search matches 2
+      #         records where plain search matches none.
+      describe 'when no fields are requested' do
+        it 'counts the records the list returns instead of failing on the un-joined association' do
+          list_getter.perform
+
+          expect(getter.count).to eq 2
+          expect(list_getter.records.count).to eq 2
+        end
+
+        it 'keeps every one-association in the include set when no fields are requested' do
+          expect(getter.includes).to contain_exactly(:owner, :cutter, :island, :eponymous_island, :location)
+        end
+      end
+
+      describe 'when fields are requested' do
+        let(:requested_fields) { { 'Tree' => 'id,name' } }
+
+        it 'counts the same records as the request carrying no fields' do
+          list_getter.perform
+
+          expect(getter.count).to eq 2
+          expect(list_getter.records.count).to eq 2
+        end
+
+        it 'keeps the same include set when fields are requested' do
+          expect(getter.includes).to contain_exactly(:owner, :cutter, :island, :eponymous_island, :location)
+        end
+      end
+
+      describe 'when extended search is off' do
+        let(:searchExtended) { '0' }
+
+        it 'matches on the own columns only and counts none of the associated records' do
+          list_getter.perform
+
+          expect(getter.count).to eq 0
+          expect(list_getter.records.count).to eq 0
+          expect(getter.includes).to eq []
+        end
+      end
+
+      describe 'when the search is nil' do
+        let(:search) { nil }
+
+        it 'counts every record' do
+          list_getter.perform
+
+          expect(getter.count).to eq 5
+          expect(list_getter.records.count).to eq 5
+        end
+      end
+
+      # NOTICE: Island's one-associations are `location` and the instance-dependent
+      #         `eponymous_tree`. Nothing else joins `trees`, so a predicate naming it
+      #         has no FROM entry — the shape `Tree` hides, since `eponymous_island`
+      #         resolves against the `isle` join `island` already contributes.
+      describe 'when a one-association carries an instance-dependent scope' do
+        let(:resource) { Island }
+        let(:search) { 'skull' }
+
+        it 'searches the own columns without failing on the un-joined association' do
+          list_getter.perform
+
+          expect(getter.count).to eq 1
+          expect(list_getter.records.count).to eq 1
+        end
+
+        describe 'when the search matches through an association the eager load does join' do
+          let(:search) { '12345' }
+
+          it 'still matches through that association' do
+            list_getter.perform
+
+            expect(getter.count).to eq 1
+            expect(list_getter.records.count).to eq 1
+          end
+        end
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_liana
 version: !ruby/object:Gem::Version
-  version: 9.20.11
+  version: 9.20.12
 platform: ruby
 authors:
 - Sandro Munda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-24 00:00:00.000000000 Z
+date: 2026-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails