forest_liana 9.20.10 → 9.20.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5449af5d3c0aa87c4c56f8417d3527e279690d22a34f02cb081cee74d2de06b1
-  data.tar.gz: '044797af4de1b516a177d859566fdbdea4e5458eb938c107077d01a19314a763'
+  metadata.gz: a13f2892e518d41f6c0aae28e4f14397086cd58f19b25c4b1fa86b4fefeaf911
+  data.tar.gz: 76853d12f9eddbf87235f2a407814d3e23938a35f51c1e77a33f99ccdee0a5e7
 SHA512:
-  metadata.gz: cce3c3edaacf3cea3dfc9ea29f3a7391cf2e1a09b399784c1be06c767d6013e600d70c7ca2fa70673451c0e18431df0d521e3cff2285408c003ef4911ca18336
-  data.tar.gz: b56dc37e18b8f8e78e730c1d8eb844731134d22be8478a27e4ea576ff75df9523f6c6ba7b7da8b07a585b97419d9b2d3058656527acad2dcb94146533e9afabd
+  metadata.gz: ff3de870bcc72b16398b83be65bc2fb363b5274f17138fdd63532b93b34a38c1ed5959514642c16fad12a31c1040ed63039f614ec24e24281076049869d853a6
+  data.tar.gz: fe52ff22910b5e3d701de07cc26c60036c67ab735a2945cde9a0c2f76739b1a3c13062eaa4b6dcab7306a3968906914db707fac023ade714783e69d006fb4df3

data/app/services/forest_liana/has_many_getter.rb

@@ -121,5 +121,77 @@ module ForestLiana
     def pagination?
       @params[:page] && @params[:page][:number]
     end
+
+    # Overrides BaseGetter#optimize_record_loading for the has-many relationship path.
+    #
+    # BaseGetter eager_loads every belongs_to/has_one/HABTM association of the target
+    # model in a single LEFT OUTER JOIN, and #records then applies LIMIT/OFFSET on top of
+    # it. When an association is declared `has_one` but is one-to-many in the data, Rails
+    # keeps it singular and does NOT switch to the limited-ids strategy, so LIMIT is applied
+    # directly to the row-multiplied JOIN output: a page collapses to fewer DISTINCT records
+    # than requested and records past the window are silently dropped (the count stays right
+    # because #count uses COUNT(DISTINCT id)).
+    #
+    # These associations are eager-loaded only to serialize the related-list columns, not
+    # for the query's WHERE/ORDER. So keep eager-loaded only the associations the current
+    # request needs a JOIN for (sort BY a relation column, or SearchQueryBuilder's extended
+    # search, which builds its OR conditions against the already-joined tables), and preload
+    # the remaining display-only associations (separate queries, no row multiplication).
+    # Filters on a relation column are unaffected: FiltersParser#apply_filters already calls
+    # `eager_load` for those associations itself, earlier in the pipeline (see #prepare_query),
+    # and that join composes fine with the one added here. LIMIT then applies to the
+    # un-multiplied base rows and returns the correct DISTINCT records.
+    def optimize_record_loading(resource, records, force_preload = true)
+      polymorphic, preload_loads = analyze_associations(resource)
+      display_includes = @includes.uniq - preload_loads - polymorphic - @optional_includes
+
+      keep_eager = display_includes & associations_to_keep_eager
+      move_to_preload = display_includes - keep_eager
+
+      result = records.eager_load(keep_eager)
+      return result unless force_preload
+
+      # NOTICE: mixing `eager_load` and `preload` in the same scope works fine on Rails 6 as
+      # long as the preloaded association isn't instance-dependent (see #567) — analyze_associations
+      # already routed those (and cross-DB ones) into `preload_loads`, so `move_to_preload` is
+      # always safe to preload; only `preload_loads` needs the Rails 7+ gate.
+      result = result.preload(move_to_preload)
+      result = result.preload(preload_loads) if Rails::VERSION::MAJOR >= 7
+
+      result
+    end
+
+    # Association names (symbols) whose JOIN the current request actually needs, so they must
+    # stay in `eager_load` rather than move to `preload`.
+    def associations_to_keep_eager
+      (associations_referenced_by_sort + associations_referenced_by_extended_search).uniq
+    end
+
+    # @params[:sort] is a comma-separated string; a leading '-' means descending and a '.'
+    # references a relation (the part before the dot). e.g. '-owner.name' => :owner
+    def associations_referenced_by_sort
+      sort = @params[:sort]
+      return [] if sort.nil? || sort.to_s.empty?
+
+      sort.to_s.split(',').map do |field|
+        field = field.strip.sub(/\A-/, '')
+        field.include?('.') ? field.split('.').first.to_sym : nil
+      end.compact
+    end
+
+    # SearchQueryBuilder#search_param, when `searchExtended=1`, adds `OR` conditions against
+    # every included one-association's columns and relies on its table already being joined.
+    # Mirror the associations it can reach so their JOIN stays eager instead of moving to
+    # preload (which never joins, on any Rails version).
+    def associations_referenced_by_extended_search
+      return [] unless @params[:search].present? && @params['searchExtended'].to_i == 1
+
+      target_model = model_association
+      includes_symbols = @includes.map(&:to_sym)
+      QueryHelper.get_one_association_names_symbol(target_model).select do |association_name|
+        includes_symbols.include?(association_name) &&
+          !SchemaUtils.polymorphic?(target_model.reflect_on_association(association_name))
+      end
+    end
   end
 end

data/lib/forest_liana/version.rb

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

data/spec/services/forest_liana/has_many_getter_pagination_spec.rb

@@ -0,0 +1,162 @@
+module ForestLiana
+  # Regression test for related-list pagination dropping records.
+  # See HasManyGetter#optimize_record_loading: a `has_one` association that actually
+  # resolves to MANY rows makes the eager_load JOIN multiply rows, so LIMIT used to
+  # collapse a page to fewer DISTINCT records than requested and silently drop the rest.
+  describe HasManyGetter, 'pagination with a has_one that is one-to-many in the data' do
+    let(:rendering_id) { 13 }
+    let(:user) { { 'id' => '1', 'rendering_id' => rendering_id } }
+    let(:scopes) { { 'scopes' => {}, 'team' => { 'id' => '1', 'name' => 'Operations' } } }
+    let(:association) { Island.reflect_on_association(:trees) }
+
+    let(:island) { Island.create!(name: 'sicily') }
+    let(:page_size) { 2 }
+    let(:params) do
+      {
+        id: island.id,
+        association_name: 'trees',
+        sort: 'id',
+        page: { size: page_size, number: 1 },
+        timezone: 'America/Nome'
+      }
+    end
+
+    subject { described_class.new(Island, association, params, user) }
+
+    before(:each) do
+      # A has_one declared on the target model that actually returns MANY rows: every tree
+      # sharing the island. Eager-loading it turns one tree into N joined rows.
+      Tree.class_eval do
+        has_one :island_neighbour, class_name: 'Tree', foreign_key: 'island_id', primary_key: 'island_id'
+      end
+
+      @alice = User.create!(name: 'Alice')
+      @bob = User.create!(name: 'Bob')
+      @trees = [
+        Tree.create!(name: 'cedar', island: island, owner: @alice),
+        Tree.create!(name: 'olive', island: island, owner: @bob),
+        Tree.create!(name: 'pine',  island: island, owner: @alice),
+        Tree.create!(name: 'fig',   island: island, owner: @bob)
+      ]
+
+      ForestLiana::ScopeManager.invalidate_scope_cache(rendering_id)
+      allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return(scopes)
+    end
+
+    after(:each) do
+      Tree._reflections.delete('island_neighbour')
+      Tree.reflections.delete('island_neighbour')
+      %w[island_neighbour island_neighbour= build_island_neighbour
+         create_island_neighbour create_island_neighbour! reload_island_neighbour].each do |m|
+        Tree.undef_method(m) rescue nil
+      end
+      Tree.destroy_all
+      Island.destroy_all
+      User.destroy_all
+    end
+
+    it 'still lists the mis-declared has_one among the eager-load candidates' do
+      expect(subject.includes).to include(:island_neighbour)
+    end
+
+    it 'returns exactly page_size DISTINCT records, not collapsed by the JOIN' do
+      subject.perform
+      ids = subject.records.map(&:id)
+
+      expect(ids.size).to eq(page_size)
+      expect(ids.uniq.size).to eq(page_size)
+    end
+
+    it 'does not JOIN the one-to-many association for a base-column sort' do
+      subject.perform
+
+      expect(subject.records.to_sql.scan(/LEFT OUTER JOIN/i)).to be_empty
+    end
+
+    it 'walks every page yielding all records exactly once' do
+      seen = []
+      pages = (@trees.size.to_f / page_size).ceil
+      pages.times do |i|
+        getter = described_class.new(
+          Island, association, params.merge(page: { size: page_size, number: i + 1 }), user
+        )
+        getter.perform
+        seen.concat(getter.records.map(&:id))
+      end
+
+      expect(seen.sort).to eq(@trees.map(&:id).sort)
+      expect(seen.uniq.size).to eq(@trees.size)
+    end
+
+    it 'keeps the total count correct' do
+      subject.perform
+
+      expect(subject.count).to eq(@trees.size)
+    end
+
+    describe 'when sorting by a relation column' do
+      let(:params) do
+        {
+          id: island.id,
+          association_name: 'trees',
+          sort: 'owner.name',
+          page: { size: 15, number: 1 },
+          timezone: 'America/Nome'
+        }
+      end
+
+      it 'keeps the relation joined and returns all records ordered by it' do
+        subject.perform
+        names = subject.records.to_a.map { |tree| tree.owner.name }
+
+        expect(names.size).to eq(@trees.size)
+        expect(names).to eq(names.sort)
+      end
+    end
+
+    describe 'when filtering by a relation column' do
+      let(:params) do
+        {
+          id: island.id,
+          association_name: 'trees',
+          filters: { field: 'owner:name', operator: 'equal', value: 'Alice' }.to_json,
+          page: { size: 15, number: 1 },
+          timezone: 'America/Nome'
+        }
+      end
+
+      it 'keeps the relation joined and returns only the matching records' do
+        subject.perform
+        records = subject.records.to_a
+
+        expect(records.size).to eq(2)
+        expect(records.map { |tree| tree.owner.name }.uniq).to eq(['Alice'])
+      end
+    end
+
+    describe 'with extended search across a display-only association' do
+      # Regression for review comment on #790: SearchQueryBuilder#search_param, with
+      # searchExtended=1, emits `OR LOWER("users"."name") LIKE ...` for every included
+      # one-association and relies on that table already being joined. `owner` isn't
+      # referenced by sort or filters here, so it would have moved to `preload` (which
+      # never joins) and blown up the query with a missing FROM-clause entry.
+      let(:params) do
+        {
+          id: island.id,
+          association_name: 'trees',
+          search: 'alice',
+          'searchExtended' => '1',
+          page: { size: 15, number: 1 },
+          timezone: 'America/Nome'
+        }
+      end
+
+      it 'keeps the searched association joined and returns only the matching records' do
+        subject.perform
+        records = subject.records.to_a
+
+        expect(records.map(&:name)).to contain_exactly('cedar', 'pine')
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_liana
 version: !ruby/object:Gem::Version
-  version: 9.20.10
+  version: 9.20.11
 platform: ruby
 authors:
 - Sandro Munda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-11 00:00:00.000000000 Z
+date: 2026-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -460,6 +460,7 @@ files:
 - spec/services/forest_liana/composite_primary_keys_spec.rb
 - spec/services/forest_liana/filters_parser_spec.rb
 - spec/services/forest_liana/forest_api_requester_spec.rb
+- spec/services/forest_liana/has_many_getter_pagination_spec.rb
 - spec/services/forest_liana/has_many_getter_spec.rb
 - spec/services/forest_liana/ip_whitelist_checker_spec.rb
 - spec/services/forest_liana/line_stat_getter_spec.rb
@@ -775,6 +776,7 @@ test_files:
 - spec/services/forest_liana/composite_primary_keys_spec.rb
 - spec/services/forest_liana/filters_parser_spec.rb
 - spec/services/forest_liana/forest_api_requester_spec.rb
+- spec/services/forest_liana/has_many_getter_pagination_spec.rb
 - spec/services/forest_liana/has_many_getter_spec.rb
 - spec/services/forest_liana/ip_whitelist_checker_spec.rb
 - spec/services/forest_liana/line_stat_getter_spec.rb