forest_liana 9.11.3 → 9.15.1

data/lib/forest_liana/schema_file_updater.rb

@@ -121,7 +121,7 @@ module ForestLiana
 
       # NOTICE: Sort keys
       @collections = @collections.map do |collection|
-        collection['fields'].sort do |field1, field2|
+        collection['fields'].sort! do |field1, field2|
           [field1['field'], field1['type'].inspect] <=> [field2['field'], field2['type'].inspect]
         end
 

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "9.11.3"
+  VERSION = "9.15.1"
 end

data/spec/dummy/app/models/tree.rb

@@ -1,10 +1,12 @@
 class Tree < ActiveRecord::Base
   belongs_to :owner, class_name: 'User', inverse_of: :trees_owned
   belongs_to :cutter, class_name: 'User', inverse_of: :trees_cut
-  belongs_to :island
+  belongs_to :island, optional: true
   belongs_to :eponymous_island,
     ->(record) { where(name: record.name) },
     class_name: 'Island',
     inverse_of: :eponymous_tree,
     optional: true
+
+  has_one :location, through: :island
 end

data/spec/helpers/forest_liana/query_helper_spec.rb

@@ -37,6 +37,7 @@ module ForestLiana
             { name: :cutter, klass: User },
             { name: :island, klass: Island },
             { name: :eponymous_island, klass: Island },
+            { name: :location, klass: Location },
           ]
         end
 
@@ -52,13 +53,17 @@ module ForestLiana
 
     describe 'get_one_association_names_symbol' do
       it 'should return the one-one associations names as symbols' do
-        expect(QueryHelper.get_one_association_names_symbol(Tree)).to eq([:owner, :cutter, :island, :eponymous_island])
+        expect(QueryHelper.get_one_association_names_symbol(Tree)).to eq(
+          [:owner, :cutter, :island, :eponymous_island, :location]
+        )
       end
     end
 
     describe 'get_one_association_names_string' do
       it 'should return the one-one associations names as strings' do
-        expect(QueryHelper.get_one_association_names_string(Tree)).to eq(['owner', 'cutter', 'island', 'eponymous_island'])
+        expect(QueryHelper.get_one_association_names_string(Tree)).to eq(
+          ['owner', 'cutter', 'island', 'eponymous_island', 'location']
+        )
       end
     end
 
@@ -71,12 +76,12 @@ module ForestLiana
         end
       end
 
-      context 'on a model having 2 belongsTo associations' do
+      context 'on a model having 3 belongsTo/hasOne associations' do
         tables_associated_to_relations_name =
           QueryHelper.get_tables_associated_to_relations_name(Tree)
 
         it 'should return the one-one associations' do
-          expect(tables_associated_to_relations_name.keys.length).to eq(2)
+          expect(tables_associated_to_relations_name.keys.length).to eq(3)
         end
 
         it 'should return relationships having a name different than the targeted model' do

data/spec/requests/resources_spec.rb

@@ -4,7 +4,9 @@ describe 'Requesting Tree resources', :type => :request  do
   let(:scope_filters) { {'scopes' => {}, 'team' => {'id' => '1', 'name' => 'Operations'}} }
   before do
     user = User.create(name: 'Michel')
-    Tree.create(name: 'Lemon Tree', owner: user, cutter: user)
+    tree = Tree.create(name: 'Lemon Tree', owner: user, cutter: user)
+    island = Island.create(name: 'Lemon Island', trees: [tree])
+    Location.create(coordinates: '1,2', island: island)
 
     Rails.cache.write('forest.users', {'1' => { 'id' => 1, 'roleId' => 1, 'rendering_id' => '1' }})
     Rails.cache.write('forest.has_permission', true)
@@ -32,6 +34,8 @@ describe 'Requesting Tree resources', :type => :request  do
   after do
     User.destroy_all
     Tree.destroy_all
+    Island.destroy_all
+    Location.destroy_all
   end
 
   token = JWT.encode({
@@ -54,7 +58,7 @@ describe 'Requesting Tree resources', :type => :request  do
   describe 'index' do
     describe 'without any filter' do
       params = {
-        fields: { 'Tree' => 'id,name' },
+        fields: { 'Tree' => 'id,name,location' },
         page: { 'number' => '1', 'size' => '10' },
         searchExtended: '0',
         sort: '-id',
@@ -98,7 +102,8 @@ describe 'Requesting Tree resources', :type => :request  do
 
       it 'should respond the tree data' do
         get '/forest/Tree', params: params, headers: headers
-        expect(JSON.parse(response.body)).to eq({
+        
+        expect(JSON.parse(response.body)).to include({
           "data" => [{
             "type" => "Tree",
             "id" => "1",
@@ -108,9 +113,30 @@ describe 'Requesting Tree resources', :type => :request  do
             },
             "links" => {
               "self" => "/forest/tree/1"
+            },
+            "relationships" => {
+              "location" => {
+                "data" => { "id" => "1", "type" => "Location" },
+                "links" => { "related" => {} }
+              }
             }
           }],
-          "included" => []
+          "included" => [{
+            "type" => "Location",
+            "id" => "1",
+            "attributes" => include(
+              "id" => 1,
+              "created_at" => nil,
+              "updated_at" => nil,
+              "coordinates" => nil
+            ),
+            "links" => { "self" => "/forest/location/1" },
+            "relationships" => {
+              "island" => {
+                "links" => { "related" => {} }
+              }
+            }
+          }]
         })
       end
     end

data/spec/services/forest_liana/pie_stat_getter_spec.rb

@@ -133,5 +133,187 @@ module ForestLiana
         end
       end
     end
+
+    describe 'aggregation methods behavior' do
+      let(:scopes) { {'scopes' => {}, 'team' => {'id' => '1', 'name' => 'Operations'}} }
+      let(:model) { Tree }
+      let(:collection) { 'trees' }
+      let(:groupByFieldName) { 'age' }
+
+      describe 'aggregation_sql method' do
+        subject { PieStatGetter.new(model, params, user) }
+
+        context 'with COUNT aggregator' do
+          let(:params) {
+            {
+              type: 'Pie',
+              sourceCollectionName: collection,
+              timezone: 'Europe/Paris',
+              aggregator: 'Count',
+              groupByFieldName: groupByFieldName
+            }
+          }
+
+          it 'should generate correct COUNT SQL' do
+            sql = subject.send(:aggregation_sql, 'count', nil)
+            expect(sql).to eq 'COUNT(DISTINCT trees.id)'
+          end
+
+          it 'should generate correct COUNT SQL with specific field' do
+            sql = subject.send(:aggregation_sql, 'count', 'age')
+            expect(sql).to eq 'COUNT(DISTINCT trees.age)'
+          end
+        end
+
+        context 'with SUM aggregator' do
+          let(:params) {
+            {
+              type: 'Pie',
+              sourceCollectionName: collection,
+              timezone: 'Europe/Paris',
+              aggregator: 'Sum',
+              aggregateFieldName: 'age',
+              groupByFieldName: groupByFieldName
+            }
+          }
+
+          it 'should generate correct SUM SQL' do
+            sql = subject.send(:aggregation_sql, 'sum', 'age')
+            expect(sql).to eq 'SUM(trees.age)'
+          end
+        end
+
+        context 'with association field' do
+          let(:params) {
+            {
+              type: 'Pie',
+              sourceCollectionName: collection,
+              timezone: 'Europe/Paris',
+              aggregator: 'Count',
+              groupByFieldName: 'owner:name'
+            }
+          }
+
+          it 'should handle association fields correctly' do
+            # Assuming Tree belongs_to :owner
+            allow(model).to receive(:reflect_on_association).with(:owner).and_return(
+              double(table_name: 'owners')
+            )
+
+            sql = subject.send(:aggregation_sql, 'count', 'owner:id')
+            expect(sql).to eq 'COUNT(DISTINCT owners.id)'
+          end
+        end
+
+        context 'with unsupported aggregator' do
+          let(:params) {
+            {
+              type: 'Pie',
+              sourceCollectionName: collection,
+              timezone: 'Europe/Paris',
+              aggregator: 'Invalid',
+              groupByFieldName: groupByFieldName
+            }
+          }
+
+          it 'should raise an error for unsupported aggregator' do
+            expect {
+              subject.send(:aggregation_sql, 'invalid', 'age')
+            }.to raise_error(ForestLiana::Errors::HTTP422Error)
+          end
+        end
+      end
+
+      describe 'aggregation_alias method' do
+        subject { PieStatGetter.new(model, params, user) }
+
+        context 'with COUNT aggregator' do
+          let(:params) {
+            {
+              type: 'Pie',
+              sourceCollectionName: collection,
+              timezone: 'Europe/Paris',
+              aggregator: 'Count',
+              groupByFieldName: groupByFieldName
+            }
+          }
+
+          it 'should return correct alias for count' do
+            alias_name = subject.send(:aggregation_alias, 'count', nil)
+            expect(alias_name).to eq 'count_id'
+          end
+        end
+
+        context 'with SUM aggregator' do
+          let(:params) {
+            {
+              type: 'Pie',
+              sourceCollectionName: collection,
+              timezone: 'Europe/Paris',
+              aggregator: 'Sum',
+              aggregateFieldName: 'age',
+              groupByFieldName: groupByFieldName
+            }
+          }
+
+          it 'should return correct alias for sum' do
+            alias_name = subject.send(:aggregation_alias, 'sum', 'age')
+            expect(alias_name).to eq 'sum_age'
+          end
+
+          it 'should handle field names with mixed case' do
+            alias_name = subject.send(:aggregation_alias, 'sum', 'TreeAge')
+            expect(alias_name).to eq 'sum_treeage'
+          end
+        end
+      end
+
+      describe 'results ordering' do
+        subject { PieStatGetter.new(model, params, user) }
+
+        context 'with COUNT aggregator' do
+          let(:params) {
+            {
+              type: 'Pie',
+              sourceCollectionName: collection,
+              timezone: 'Europe/Paris',
+              aggregator: 'Count',
+              groupByFieldName: groupByFieldName
+            }
+          }
+
+          it 'should return results ordered by count descending' do
+            subject.perform
+
+            expect(subject.record.value).to eq [
+                                                 { :key => 3, :value => 5},
+                                                 { :key => 15, :value => 4 }
+                                               ]
+          end
+        end
+
+        context 'with SUM aggregator' do
+          let(:params) {
+            {
+              type: 'Pie',
+              sourceCollectionName: collection,
+              timezone: 'Europe/Paris',
+              aggregator: 'Sum',
+              aggregateFieldName: 'age',
+              groupByFieldName: groupByFieldName
+            }
+          }
+
+          it 'should return results ordered by sum descending' do
+            subject.perform
+
+            expect(subject.record.value).to eq [
+                                                 { :key => 15, :value => 60 },
+                                                 { :key => 3, :value => 15 }
+                                               ]
+          end
+        end
+      end
+    end
   end
 end

data/spec/services/forest_liana/resources_getter_spec.rb

@@ -4,7 +4,7 @@ module ForestLiana
     let(:pageSize) { 10 }
     let(:pageNumber) { 1 }
     let(:sort) { 'id' }
-    let(:fields) {}
+    let(:fields) { { resource.name => 'id' } }
     let(:filters) {}
     let(:scopes) { {'scopes' => {}, 'team' => {'id' => '1', 'name' => 'Operations'}} }
     let(:rendering_id) { 13 }
@@ -38,7 +38,7 @@ module ForestLiana
       clean_database
 
       users = ['Michel', 'Robert', 'Vince', 'Sandro', 'Olesya', 'Romain', 'Valentin', 'Jason', 'Arnaud', 'Jeff', 'Steve', 'Marc', 'Xavier', 'Paul', 'Mickael', 'Mike', 'Maxime', 'Gertrude', 'Monique', 'Mia', 'Rachid', 'Edouard', 'Sacha', 'Caro', 'Amand', 'Nathan', 'Noémie', 'Robin', 'Gaelle', 'Isabelle']
-      .map { |name| User.create(name: name) }
+                .map { |name| User.create(name: name) }
 
       islands = [
         { :name => 'Skull', :updated_at => Time.now - 1.years },
@@ -190,6 +190,7 @@ module ForestLiana
 
     describe 'when on a model having a reserved SQL word as name' do
       let(:resource) { Reference }
+      let(:fields) { { resource.name => 'id' } }
 
       it 'should get the ressource properly' do
         getter.perform
@@ -219,6 +220,7 @@ module ForestLiana
 
     describe 'when sorting by a belongs_to association' do
       let(:resource) { Tree }
+      let(:fields) { { resource.name => 'id' } }
       let(:sort) { 'owner.name' }
 
       it 'should get only the expected records' do
@@ -288,21 +290,37 @@ module ForestLiana
       end
     end
 
+    describe 'when getting a has_one through association' do
+      let(:resource) { Tree }
+      let(:fields) { { 'Tree' => 'id,location' } }
+
+      it 'should get the expected records, including the foreign_key for the direct association' do
+        getter.perform
+        records = getter.records
+        count = getter.count
+
+        expect(records.count).to eq Tree.count
+        expect(count).to eq Tree.count
+        expect(records.map(&:id)).to match_array(Tree.pluck(:id))
+        expect(records.map(&:island_id)).to match_array(Tree.pluck(:island_id))
+      end
+    end
+
     describe 'when filtering on an ambiguous field' do
       let(:resource) { Tree }
       let(:pageSize) { 5 }
-      let(:fields) { { 'Tree' => 'id' } }
+      let(:fields) { { 'Tree' => 'id,name', 'cutter' => 'id' } }
       let(:filters) { {
         aggregator: 'and',
         conditions: [{
-          field: 'created_at',
-          operator: 'after',
-          value: "#{Time.now - 6.year}",
-        }, {
-          field: 'cutter:name',
-          operator: 'equal',
-          value: 'Michel'
-        }]
+                       field: 'created_at',
+                       operator: 'after',
+                       value: "#{Time.now - 6.year}",
+                     }, {
+                       field: 'cutter:name',
+                       operator: 'equal',
+                       value: 'Michel'
+                     }]
       }.to_json }
 
       it 'should get only the expected records' do
@@ -314,7 +332,6 @@ module ForestLiana
         expect(count).to eq 1
         expect(records.first.id).to eq 3
         expect(records.first.name).to eq 'Apple Tree'
-        expect(records.first.cutter.name).to eq 'Michel'
       end
     end
 
@@ -361,7 +378,7 @@ module ForestLiana
     describe 'when sorting on an ambiguous field name with a filter' do
       let(:resource) { Tree }
       let(:sort) { '-name' }
-      let(:fields) { { 'Tree' => 'id' } }
+      let(:fields) { { 'Tree' => 'id,name' } }
       let(:filters) { {
         field: 'cutter:name',
         operator: 'equal',
@@ -399,7 +416,7 @@ module ForestLiana
 
     describe 'when filtering on an updated_at field of an associated collection' do
       let(:resource) { Tree }
-      let(:fields) { { 'Tree' => 'id' } }
+      let(:fields) { { 'Tree' => 'id,name' } }
       let(:filters) { {
         field: 'island:updated_at',
         operator: 'previous_year'
@@ -492,16 +509,16 @@ module ForestLiana
 
       it 'should raise the right error' do
         expect { getter }.to raise_error(
-          ForestLiana::Errors::NotImplementedMethodError,
-           "method filter on smart field 'alter_coordinates' not found"
-        )
+                               ForestLiana::Errors::NotImplementedMethodError,
+                               "method filter on smart field 'alter_coordinates' not found"
+                             )
       end
     end
 
     describe 'when scopes are defined' do
       let(:resource) { Island }
       let(:pageSize) { 15 }
-      let(:fields) { }
+      let(:fields) { { resource.name => 'id' } }
       let(:filters) { }
       let(:scopes) {
         {
@@ -537,10 +554,10 @@ module ForestLiana
         let(:filters) { {
           aggregator: 'and',
           conditions: [{
-            field: 'name',
-            operator: 'contains',
-            value: 'a',
-          }]
+                         field: 'name',
+                         operator: 'contains',
+                         value: 'a',
+                       }]
         }.to_json }
 
         it 'should get only the records matching the scope' do
@@ -554,6 +571,84 @@ module ForestLiana
           expect(records.second.name).to eq 'Treasure'
         end
       end
+
+      describe '#perform' do
+        let(:resource) { User }
+        let(:fields) { nil }
+        let(:sort) { nil }
+        let(:filters) { nil }
+
+        it 'does not raise an error when params[:fields] is nil' do
+          expect {
+            getter.perform
+          }.not_to raise_error
+
+          records = getter.records
+          count = getter.count
+
+          expect(records).to all(be_a(User))
+          expect(count).to eq User.count
+        end
+      end
+
+      describe '#extract_associations_from_filter' do
+        let(:resource) { Tree }
+
+        before { init_scopes }
+
+        context 'with a single filter as JSON string' do
+          let(:filters) {
+            {
+              field: 'island:updated_at',
+              operator: 'equal',
+              value: '2024-01-01'
+            }.to_json
+          }
+
+          it 'extracts the correct association' do
+            expect(getter.send(:extract_associations_from_filter)).to eq [:island]
+          end
+        end
+
+        context 'with grouped conditions as JSON string' do
+          let(:filters) {
+            {
+              aggregator: 'and',
+              conditions: [
+                { field: 'island:updated_at', operator: 'equal', value: '2024-01-01' },
+                { field: 'owner:name', operator: 'equal', value: 'Michel' },
+                { field: 'id', operator: 'present', value: nil }
+              ]
+            }.to_json
+          }
+
+          it 'extracts all unique associations' do
+            expect(getter.send(:extract_associations_from_filter)).to match_array [:island, :owner]
+          end
+        end
+
+        context 'when filters has no association field' do
+          let(:filters) {
+            {
+              field: 'id',
+              operator: 'equal',
+              value: 1
+            }.to_json
+          }
+
+          it 'returns an empty array' do
+            expect(getter.send(:extract_associations_from_filter)).to eq []
+          end
+        end
+
+        context 'when filters is nil' do
+          let(:filters) { nil }
+
+          it 'returns an empty array' do
+            expect(getter.send(:extract_associations_from_filter)).to eq []
+          end
+        end
+      end
     end
   end
-end
+end

data/spec/services/forest_liana/schema_adapter_spec.rb

@@ -61,7 +61,18 @@ module ForestLiana
           end
 
           expect(collection.fields.map { |field| field[:field].to_s}).to eq(
-            ["age", "created_at", "cutter", "eponymous_island", "id", "island", "name", "owner", "updated_at"]
+            [
+              "age",
+              "created_at",
+              "cutter",
+              "eponymous_island",
+              "id",
+              "island",
+              "location",
+              "name",
+              "owner",
+              "updated_at"
+            ]
           )
         end
       end

data/spec/services/forest_liana/serializer_factory_spec.rb

@@ -0,0 +1,53 @@
+module ForestLiana
+  describe SerializerFactory do
+    describe '#serializer_for has_one_relationships patch' do
+      let(:user) { User.create!(name: 'PatchTest') }
+      let(:island) { Island.create!(name: 'TestIsland') }
+      let(:tree) { Tree.create!(name: 'TestTree', island: island, owner: user) }
+
+      it 'simulates has_one relation with only primary key' do
+        factory = described_class.new
+        serializer_class = factory.serializer_for(Tree)
+
+        serializer_class.send(:has_one, :island) { }
+
+        instance = serializer_class.new(tree, fields: {
+          'Island' => [:id],
+          'Tree' => [:island]
+        })
+
+        relationships = instance.send(:has_one_relationships)
+        expect(relationships).to have_key(:island)
+        relation_data = relationships[:island]
+        expect(relation_data[:attr_or_block]).to be_a(Proc)
+        model = relation_data[:attr_or_block].call
+
+        expect(model).to be_a(Island)
+        expect(model.id).to eq(island.id)
+      end
+
+      it 'returns nil if foreign key is nil' do
+        tree_without_island = Tree.create!(name: 'NoIslandTree', island_id: nil, owner: user)
+
+        factory = described_class.new
+        serializer_class = factory.serializer_for(Tree)
+
+        serializer_class.send(:has_one, :island) { }
+
+        instance = serializer_class.new(tree_without_island, fields: {
+          'Island' => [:id],
+          'Tree' => [:island]
+        })
+
+        relationships = instance.send(:has_one_relationships)
+        expect(relationships).to have_key(:island)
+        relation_data = relationships[:island]
+        expect(relation_data[:attr_or_block]).to be_a(Proc)
+        model = relation_data[:attr_or_block].call
+
+        expect(model).to be_nil
+      end
+
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_liana
 version: !ruby/object:Gem::Version
-  version: 9.11.3
+  version: 9.15.1
 platform: ruby
 authors:
 - Sandro Munda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-09 00:00:00.000000000 Z
+date: 2025-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -254,6 +254,7 @@ files:
 - app/services/forest_liana/ability/permission.rb
 - app/services/forest_liana/ability/permission/request_permission.rb
 - app/services/forest_liana/ability/permission/smart_action_checker.rb
+- app/services/forest_liana/aggregation_helper.rb
 - app/services/forest_liana/apimap_sorter.rb
 - app/services/forest_liana/authentication.rb
 - app/services/forest_liana/authorization_getter.rb
@@ -317,6 +318,7 @@ files:
 - config/routes.rb
 - config/routes/actions.rb
 - lib/forest_liana.rb
+- lib/forest_liana/active_record_override.rb
 - lib/forest_liana/base64_string_io.rb
 - lib/forest_liana/bootstrapper.rb
 - lib/forest_liana/collection.rb
@@ -430,6 +432,7 @@ files:
 - spec/services/forest_liana/resources_getter_spec.rb
 - spec/services/forest_liana/schema_adapter_spec.rb
 - spec/services/forest_liana/scope_manager_spec.rb
+- spec/services/forest_liana/serializer_factory_spec.rb
 - spec/services/forest_liana/smart_action_field_validator_spec.rb
 - spec/services/forest_liana/smart_action_form_parser_spec.rb
 - spec/services/forest_liana/utils/context_variables_injector_spec.rb
@@ -735,6 +738,7 @@ test_files:
 - spec/services/forest_liana/resources_getter_spec.rb
 - spec/services/forest_liana/schema_adapter_spec.rb
 - spec/services/forest_liana/scope_manager_spec.rb
+- spec/services/forest_liana/serializer_factory_spec.rb
 - spec/services/forest_liana/smart_action_field_validator_spec.rb
 - spec/services/forest_liana/smart_action_form_parser_spec.rb
 - spec/services/forest_liana/utils/context_variables_injector_spec.rb