forest_liana 9.22.2 → 9.22.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2519878c68b98965bc3b8e31cf9ae9e8253f9d215cf724d99233e55cb37ab8c5
-  data.tar.gz: ae92f459f29ab022290ad09f33e9d1cec654d86fce2784cb425e8c8924b87e59
+  metadata.gz: f8365b7c92d4157a34acd7f00af2c3d515976b96884eef48c0a0e72c775b1ea0
+  data.tar.gz: a61cfdd476921b56e293014854693c3aa39ffd6d8474544273be222f91c5d0db
 SHA512:
-  metadata.gz: 6aaa74f4333c30a763077f5ef1e03247e9c42fd190608ef453263406485ecee48aae37fe8b8b927be1e5fadcf5eb12105c9ea9f5e1b43d7e6e66f78d6a1799af
-  data.tar.gz: 18e7851795ff42410beb2a87db9fb0cec346e4734cd04401461974529bf3d8e4a4ee61fca0e1d143428447f199b6c42cafe48f7c40a4e2d0c2841773e4bf254c
+  metadata.gz: 8ee81334205b47404f4fc9349fcde08b8d38be877a525a1cfb8bc1481de1b435d88b0724d48552cbc111735a751b2f84c60a49cc4142a5a7c3a9fab6df201d49
+  data.tar.gz: dec06373edbb86308bb9577c0f20d61a747ad9fa0fac691b1f70fadada3d2e27406337b188eda61f10c5ad96405c6d65db77bd4e5144dd079e9445d1b1a13cc4

data/app/services/forest_liana/aggregation_helper.rb

@@ -1,22 +1,22 @@
 module ForestLiana
   module AggregationHelper
-    def resolve_field_path(field_param, default_field = 'id')
+    def resolve_field_path(field_param, default_field = 'id', resource = @resource)
       if field_param.blank?
-        default_field ||= @resource.primary_key || 'id'
-        return "#{@resource.table_name}.#{default_field}"
+        default_field ||= resource.primary_key || 'id'
+        return "#{resource.table_name}.#{default_field}"
       end
 
       if field_param.include?(':')
         association, field = field_param.split ':'
-        associated_resource = @resource.reflect_on_association(association.to_sym)
+        associated_resource = resource.reflect_on_association(association.to_sym)
         "#{associated_resource.table_name}.#{field}"
       else
-        "#{@resource.table_name}.#{field_param}"
+        "#{resource.table_name}.#{field_param}"
       end
     end
 
-    def aggregation_sql(type, field)
-      field_path = resolve_field_path(field)
+    def aggregation_sql(type, field, resource = @resource)
+      field_path = resolve_field_path(field, 'id', resource)
 
       case type
       when 'sum'

data/app/services/forest_liana/apimap_sorter.rb

@@ -110,15 +110,16 @@ module ForestLiana
     private
 
     def sort_array_of_objects(array)
-      array.sort! do |element1, element2|
-        [element1['type'], element1['id']] <=>  [element2['type'], element2['id']]
-      end
+      array.sort_by! { |element| [element['type'].to_s, element['id'].to_s] }
     end
 
+    # NOTICE: A field 'type' is a String ('String'), an Array (['String'] for an array column)
+    # or a Hash (a nested type), and those are not comparable with one another:
+    # `['String'] <=> 'String'` returns nil, which makes `sort` raise an ArgumentError as soon
+    # as two fields share a name. Only the tie-breaker ever needs to be total, so JSON-ifying
+    # that one alone keeps the primary key byte-for-byte identical and the apimap churn-free.
     def sort_array_of_fields(array)
-      array.sort do |field1, field2|
-        [field1['field'], field1['type']] <=>  [field2['field'], field2['type']]
-      end
+      array.sort_by { |field| [field['field'].to_s, field['type'].to_json] }
     end
 
     def reorder_keys_basic(object)

data/app/services/forest_liana/leaderboard_stat_getter.rb

@@ -4,9 +4,10 @@ module ForestLiana
 
     def initialize(parent_model, params, forest_user)
       @resource = parent_model
-      @scoped_parent_model = get_scoped_model(parent_model, forest_user, params[:timezone])
-      child_model = @scoped_parent_model.reflect_on_association(params[:relationshipFieldName]).klass
-      @scoped_child_model = get_scoped_model(child_model, forest_user, params[:timezone])
+      @scoped_parent_model = get_scoped_model(parent_model, forest_user, params[:timezone]) || parent_model.unscoped
+      @relationship_field_name = params[:relationshipFieldName].to_sym
+      @child_model = @scoped_parent_model.reflect_on_association(@relationship_field_name).klass
+      @child_scope = get_scoped_model(@child_model, forest_user, params[:timezone])
       @label_field = params[:labelFieldName]
       @aggregate = params[:aggregator].downcase
       @aggregate_field = params[:aggregateFieldName]
@@ -15,17 +16,25 @@ module ForestLiana
     end
 
     def perform
-      includes = ForestLiana::QueryHelper.get_one_association_names_symbol(@scoped_child_model)
-
       alias_name = aggregation_alias(@aggregate, @aggregate_field)
-
-      result = @scoped_child_model
-        .joins(includes)
-        .where({ @scoped_parent_model.name.downcase.to_sym => @scoped_parent_model })
+      # NOTICE: The chart groups on the parent collection and aggregates its related records, so
+      #         the query starts from the parent: querying the related model leaves the parent
+      #         table out of the FROM clause unless it happens to be one of its belongs_to.
+      aggregation = aggregation_sql(@aggregate, @aggregate_field, @child_model)
+      records = @scoped_parent_model.joins(@relationship_field_name)
+
+      # NOTICE: The related collection scope goes through a subquery: merging it would re-root its
+      #         joins onto the parent, and reorder drops the ordering of the parent default_scope.
+      if @child_scope
+        child_key = @child_model.primary_key
+        records = records.where(@child_model.table_name => { child_key => @child_scope.select(child_key) })
+      end
+
+      result = records
         .group(@group_by)
-        .order(Arel.sql("#{alias_name} DESC"))
+        .reorder(Arel.sql("#{alias_name} DESC"))
         .limit(@limit)
-        .pluck(@group_by, Arel.sql("#{aggregation_sql(@aggregate, @aggregate_field)} AS #{alias_name}"))
+        .pluck(@group_by, Arel.sql("#{aggregation} AS #{alias_name}"))
         .map { |key, value| { key: key, value: value } }
 
       @record = Model::Stat.new(value: result)
@@ -34,7 +43,7 @@ module ForestLiana
     def get_scoped_model(model, forest_user, timezone)
       scope_filters = ForestLiana::ScopeManager.get_scope(model.name, forest_user)
 
-      return model.unscoped if scope_filters.blank?
+      return if scope_filters.blank?
 
       FiltersParser.new(scope_filters, model, timezone, @params).apply_filters
     end

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "9.22.2"
+  VERSION = "9.22.4"
 end

data/spec/services/forest_liana/apimap_sorter_spec.rb

@@ -171,6 +171,80 @@ module ForestLiana
           expect(apimap_sorted['meta']['stack'].keys).to eq(['database_type', 'orm_version'])
         end
       end
+
+      context 'on an apimap with fields sharing a name but not a comparable type' do
+        # NOTICE: a field 'type' is a String ('String'), an Array (['String'] for an array
+        # column) or a Hash (a nested type). The sort used to compare those values
+        # directly, so `['String'] <=> 'String'` returned nil and `sort` raised
+        # `ArgumentError: comparison of Hash with Hash failed`. The rescue in `perform`
+        # swallowed it and returned a half-processed apimap: collections that were never
+        # reached kept attributes outside KEYS_COLLECTION (such as 'search_fields'), and
+        # the Forest API rejects those with `HTTP 400 ValidationFailedError`.
+        let(:apimap) do
+          ActiveSupport::JSON.decode(ActiveSupport::JSON.encode({
+            'meta': {
+              stack: {
+                'orm_version': '4.34.9',
+                'database_type': 'postgresql',
+              },
+              liana: 'forest-rails',
+              'liana_version': '1.5.24',
+            },
+            'data': [{
+              id: 'posts',
+              type: 'collections',
+              attributes: {
+                name: 'posts',
+                fields: [
+                  { field: 'tags', type: ['String'] },
+                  { field: 'tags', type: 'String' },
+                  { field: 'meta', type: { fields: [{ field: 'locale', type: 'String' }] } },
+                  { field: 'meta', type: 'String' },
+                  { field: 'id', type: 'Number' },
+                ],
+              }
+            }, {
+              id: 'zebras',
+              type: 'collections',
+              attributes: {
+                'search_fields': ['name'],
+                fields: [
+                  { field: 'id', type: 'Number' },
+                ],
+                name: 'zebras',
+              }
+            }]
+          }))
+        end
+
+        let(:apimap_sorted) { ApimapSorter.new(apimap).perform }
+
+        it 'should reorder the whole apimap without bailing out' do
+          expect(FOREST_LOGGER).not_to receive(:warn)
+
+          apimap_sorted
+        end
+
+        it 'should sort the fields of the offending collection' do
+          expect(apimap_sorted['data'][0]['attributes']['fields'].map { |field| field['field'] })
+            .to eq(['id', 'meta', 'meta', 'tags', 'tags'])
+        end
+
+        it 'should keep a deterministic order between the non-comparable types' do
+          tag_types = apimap_sorted['data'][0]['attributes']['fields']
+            .select { |field| field['field'] == 'tags' }
+            .map { |field| field['type'] }
+          expect(tag_types).to eq(['String', ['String']])
+        end
+
+        it 'should keep processing the collections after the offending one' do
+          expect(apimap_sorted['data'][1]['attributes'].keys).to eq(['name', 'fields'])
+        end
+
+        it 'should not leak collection attributes that are not part of the schema' do
+          expect(apimap_sorted['data'][1]['attributes']).not_to have_key('search_fields')
+        end
+      end
     end
 
     describe 'a smart field dependencies key' do

data/spec/services/forest_liana/leaderboard_stat_getter_spec.rb

@@ -0,0 +1,157 @@
+module ForestLiana
+  describe LeaderboardStatGetter do
+    let(:rendering_id) { 13 }
+    let(:user) { { 'id' => '1', 'rendering_id' => rendering_id } }
+    let(:scopes) { {'scopes' => {}, 'team' => {'id' => '1', 'name' => 'Operations'}} }
+
+    before(:each) do
+      ForestLiana::ScopeManager.invalidate_scope_cache(rendering_id)
+      allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return(scopes)
+    end
+
+    describe 'on a relationship whose model does not belong to the parent collection' do
+      let(:params) {
+        {
+          type: 'Leaderboard',
+          timezone: 'Europe/Paris',
+          relationshipFieldName: 'addresses',
+          labelFieldName: 'name',
+          aggregator: 'Count',
+          limit: 5
+        }
+      }
+
+      before(:each) do
+        king = User.create!(name: 'Aegon', title: 'king')
+        villager = User.create!(name: 'Davos', title: 'villager')
+
+        2.times { |index| Address.create!(line1: "#{index} Dragonstone", addressable: king) }
+        Address.create!(line1: '1 Flea Bottom', addressable: villager)
+      end
+
+      it 'ranks the parent records by number of related records' do
+        getter = LeaderboardStatGetter.new(User, params, user)
+        getter.perform
+
+        expect(getter.record.value).to eq([
+          { key: 'Aegon', value: 2 },
+          { key: 'Davos', value: 1 }
+        ])
+      end
+    end
+
+    describe 'on a relationship whose model belongs to the parent collection' do
+      let(:aggregator) { 'Count' }
+      let(:aggregate_field) { nil }
+      let(:params) {
+        {
+          type: 'Leaderboard',
+          timezone: 'Europe/Paris',
+          relationshipFieldName: 'trees',
+          labelFieldName: 'name',
+          aggregator: aggregator,
+          aggregateFieldName: aggregate_field,
+          limit: 5
+        }
+      }
+
+      before(:each) do
+        dragonstone = Island.create!(name: 'Dragonstone')
+        skagos = Island.create!(name: 'Skagos')
+
+        Tree.create!(name: 'Old Tree', age: 15, island: dragonstone)
+        Tree.create!(name: 'Young Tree', age: 3, island: dragonstone)
+        Tree.create!(name: 'Lone Tree', age: 30, island: skagos)
+      end
+
+      it 'counts the related records, not the parent ones' do
+        getter = LeaderboardStatGetter.new(Island, params, user)
+        getter.perform
+
+        expect(getter.record.value).to eq([
+          { key: 'Dragonstone', value: 2 },
+          { key: 'Skagos', value: 1 }
+        ])
+      end
+
+      context 'when the chart sums a field of the related records' do
+        let(:aggregator) { 'Sum' }
+        let(:aggregate_field) { 'age' }
+
+        it 'sums that field on the related model' do
+          getter = LeaderboardStatGetter.new(Island, params, user)
+          getter.perform
+
+          expect(getter.record.value).to eq([
+            { key: 'Skagos', value: 30 },
+            { key: 'Dragonstone', value: 18 }
+          ])
+        end
+      end
+
+      context 'when the related collection is scoped on a field of its own relationship' do
+        let(:scopes) {
+          {
+            'scopes' => {
+              'Tree' => { 'aggregator' => 'and', 'conditions' => [{ 'field' => 'owner:name', 'operator' => 'equal', 'value' => 'Aegon' }] }
+            },
+            'team' => { 'id' => '1', 'name' => 'Operations' }
+          }
+        }
+
+        before(:each) do
+          Tree.find_by!(name: 'Lone Tree').update!(owner: User.create!(name: 'Aegon'))
+          Tree.find_by!(name: 'Old Tree').update!(owner: User.create!(name: 'Davos'))
+        end
+
+        it 'only aggregates the related records the scope keeps' do
+          getter = LeaderboardStatGetter.new(Island, params, user)
+          getter.perform
+
+          expect(getter.record.value).to eq([
+            { key: 'Skagos', value: 1 }
+          ])
+        end
+      end
+    end
+
+    describe 'on a scoped parent collection whose default_scope orders' do
+      let(:scopes) {
+        {
+          'scopes' => {
+            'Owner' => { 'aggregator' => 'and', 'conditions' => [{ 'field' => 'name', 'operator' => 'not_equal', 'value' => 'Theon' }] }
+          },
+          'team' => { 'id' => '1', 'name' => 'Operations' }
+        }
+      }
+      let(:params) {
+        {
+          type: 'Leaderboard',
+          timezone: 'Europe/Paris',
+          relationshipFieldName: 'trees',
+          labelFieldName: 'name',
+          aggregator: 'Count',
+          limit: 5
+        }
+      }
+
+      before(:each) do
+        jon = Owner.create!(name: 'Jon', hired_at: 2.years.ago)
+        sansa = Owner.create!(name: 'Sansa', hired_at: 1.year.ago)
+
+        Tree.create!(name: 'Weirwood', owner_id: jon.id)
+        2.times { |index| Tree.create!(name: "Pine #{index}", owner_id: sansa.id) }
+      end
+
+      it 'ranks by the aggregate, not by the default_scope ordering' do
+        getter = LeaderboardStatGetter.new(Owner, params, user)
+        getter.perform
+
+        expect(getter.record.value).to eq([
+          { key: 'Sansa', value: 2 },
+          { key: 'Jon', value: 1 }
+        ])
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_liana
 version: !ruby/object:Gem::Version
-  version: 9.22.2
+  version: 9.22.4
 platform: ruby
 authors:
 - Sandro Munda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-24 00:00:00.000000000 Z
+date: 2026-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -501,6 +501,7 @@ files:
 - 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/leaderboard_stat_getter_spec.rb
 - spec/services/forest_liana/line_stat_getter_spec.rb
 - spec/services/forest_liana/pie_stat_getter_spec.rb
 - spec/services/forest_liana/projection_parser_spec.rb
@@ -848,6 +849,7 @@ test_files:
 - 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/leaderboard_stat_getter_spec.rb
 - spec/services/forest_liana/line_stat_getter_spec.rb
 - spec/services/forest_liana/pie_stat_getter_spec.rb
 - spec/services/forest_liana/projection_parser_spec.rb