forest_liana 9.15.4 → 9.15.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01b3a5629878eddd5cfdeea4bcb0fadcdd46c5211ac3bf327d8cda5cc6ecb068
-  data.tar.gz: a05b24374ac64efca265824dcd69167c690b1a7bff67fbafc06ab9d497fa2531
+  metadata.gz: 34a394e776ab9ef99fe30e7e367e834f84e5e0fdf0a2314aaa76ec368dc7f0a3
+  data.tar.gz: 619adc9e67f4d7a9182be43a383a688a7782de23718a3c2e1640cf361386b61d
 SHA512:
-  metadata.gz: 89fcfaf157e5cc76277e85eba8ad01ba92450e8f9081a8602881ae5d7b20bdd23e11b0029ad144000b7b886f081d2f5f0a7444084990df1678a44d471dd94fd8
-  data.tar.gz: b02ae1262881d03d225f7795e92e26764a738343ba8880b36ed13d44521a3d09686db209dda8a4ecfa260afe3990859ee2eff348892f74891d7e60b11791fcd1
+  metadata.gz: b56de9223cf035c62a35bd1cebf6a8390ce0887d11818940a8f945ca90295c0d4ad7d7d63e6991378c224f2f3c549ab011e0127cf41b8e2e99a83c9eabf8d559
+  data.tar.gz: db9cf2fa2a26ac1f1d084ffab1046b7cb9d22d1cc4bc4bf36e5dc196ca58792102a2e1d636117d96f50da32f303b4ac57074dd0bf23f8397ccb74523aea97e81

data/app/controllers/forest_liana/application_controller.rb

@@ -49,6 +49,10 @@ module ForestLiana
 
     def serialize_models(records, options = {}, fields_searched = [])
       options[:is_collection] = true
+      if options[:params] && options[:params][:fields].nil?
+        options[:context] = { unoptimized: true }.merge(options[:context] || {})
+      end
+
       json = ForestAdmin::JSONAPI::Serializer.serialize(records, options)
 
       if options[:params] && options[:params][:search]
@@ -63,6 +67,10 @@ module ForestLiana
       force_utf8_encoding(json)
     end
 
+    def get_collection
+      raise NotImplementedError, "#{self.class} must implement #get_collection"
+    end
+
     def authenticate_user_from_jwt
       begin
         if request.headers

data/app/helpers/forest_liana/decoration_helper.rb

@@ -14,6 +14,10 @@ module ForestLiana
     def self.decorate_for_search(records_serialized, field_names, search_value)
       match_fields = {}
       records_serialized['data'].each_with_index do |record, index|
+        unless record['attributes']
+          raise ArgumentError, "Missing 'attributes' key in record #{record}"
+        end
+
         field_names.each do |field_name|
           value = record['attributes'][field_name]
           if value

data/app/services/forest_liana/has_many_getter.rb

@@ -4,6 +4,8 @@ module ForestLiana
     attr_reader :includes
     attr_reader :records_count
 
+    SUPPORTED_ASSOCIATION_MACROS = [:belongs_to, :has_one, :has_and_belongs_to_many].freeze
+
     def initialize(resource, association, params, forest_user)
       @resource = resource
       @association = association
@@ -43,22 +45,21 @@ module ForestLiana
         .reflect_on_all_associations
         .select do |association|
 
+          next false unless SUPPORTED_ASSOCIATION_MACROS.include?(association.macro)
+
           if SchemaUtils.polymorphic?(association)
             inclusion = SchemaUtils.polymorphic_models(association)
-                                   .all? { |model| SchemaUtils.model_included?(model) } &&
-              [:belongs_to, :has_and_belongs_to_many].include?(association.macro)
+                                   .all? { |model| SchemaUtils.model_included?(model) }
           else
-            inclusion = SchemaUtils.model_included?(association.klass) &&
-              [:belongs_to, :has_and_belongs_to_many].include?(association.macro)
+            inclusion = SchemaUtils.model_included?(association.klass)
           end
 
-            if @field_names_requested
-              inclusion && @field_names_requested.include?(association.name)
-            else
-              inclusion
-            end
+          if @field_names_requested.any?
+            inclusion && @field_names_requested.include?(association.name)
+          else
+            inclusion
           end
-        .map { |association| association.name }
+        end.map(&:name)
     end
 
     def field_names_requested

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "9.15.4"
+  VERSION = "9.15.6"
 end

data/spec/helpers/forest_liana/decoration_helper_spec.rb

@@ -0,0 +1,234 @@
+module ForestLiana
+  describe DecorationHelper do
+    describe '.detect_match_and_decorate' do
+      let(:record) do
+        {
+          'type' => 'User',
+          'id' => '123',
+          'attributes' => {
+            'id' => 123,
+            'name' => 'John Doe',
+            'email' => 'john@example.com'
+          },
+          'links' => { 'self' => '/forest/user/123' },
+          'relationships' => {}
+        }
+      end
+      let(:index) { 0 }
+      let(:field_name) { 'name' }
+      let(:value) { 'John Doe' }
+      let(:search_value) { 'john' }
+      let(:match_fields) { {} }
+
+      context 'when value matches search_value' do
+        it 'creates new match entry when none exists' do
+          described_class.detect_match_and_decorate(record, index, field_name, value, search_value, match_fields)
+
+          expect(match_fields[index]).to eq({
+                                              id: '123',
+                                              search: ['name']
+                                            })
+        end
+
+        it 'appends to existing match entry' do
+          match_fields[index] = { id: '123', search: ['email'] }
+
+          described_class.detect_match_and_decorate(record, index, field_name, value, search_value, match_fields)
+
+          expect(match_fields[index][:search]).to contain_exactly('email', 'name')
+        end
+
+        it 'performs case-insensitive matching' do
+          search_value = 'JOHN'
+
+          described_class.detect_match_and_decorate(record, index, field_name, value, search_value, match_fields)
+
+          expect(match_fields[index]).not_to be_nil
+          expect(match_fields[index][:search]).to include('name')
+        end
+
+        it 'matches partial strings' do
+          search_value = 'oe'
+
+          described_class.detect_match_and_decorate(record, index, field_name, value, search_value, match_fields)
+
+          expect(match_fields[index][:search]).to include('name')
+        end
+      end
+
+      context 'when value does not match search_value' do
+        let(:search_value) { 'jane' }
+
+        it 'does not create match entry' do
+          described_class.detect_match_and_decorate(record, index, field_name, value, search_value, match_fields)
+
+          expect(match_fields).to be_empty
+        end
+
+        it 'does not modify existing match_fields' do
+          existing_data = { id: '456', search: ['other_field'] }
+          match_fields[1] = existing_data.dup
+
+          described_class.detect_match_and_decorate(record, index, field_name, value, search_value, match_fields)
+
+          expect(match_fields[1]).to eq(existing_data)
+          expect(match_fields[index]).to be_nil
+        end
+      end
+
+      context 'when regex matching raises an exception' do
+        let(:search_value) { '[invalid_regex' }
+
+        it 'handles the exception gracefully' do
+          expect {
+            described_class.detect_match_and_decorate(record, index, field_name, value, search_value, match_fields)
+          }.not_to raise_error
+
+          expect(match_fields).to be_empty
+        end
+      end
+
+      context 'with special regex characters in search_value' do
+        let(:search_value) { '.' }
+        let(:value) { 'test.email@domain.com' }
+
+        it 'treats special characters as literal characters' do
+          described_class.detect_match_and_decorate(record, index, field_name, value, search_value, match_fields)
+
+          expect(match_fields[index][:search]).to include('name')
+        end
+      end
+    end
+
+    describe '.decorate_for_search' do
+      let(:search_value) { 'john' }
+      let(:field_names) { ['name', 'email'] }
+
+      context 'with valid records' do
+        let(:records_serialized) do
+          {
+            'data' => [
+              {
+                'type' => 'User',
+                'id' => '1',
+                'attributes' => {
+                  'id' => 1,
+                  'name' => 'John Doe',
+                  'email' => 'john@example.com'
+                },
+                'links' => { 'self' => '/forest/user/1' },
+                'relationships' => {}
+              },
+              {
+                'type' => 'User',
+                'id' => '2',
+                'attributes' => {
+                  'id' => 2,
+                  'name' => 'Jane Smith',
+                  'email' => 'jane@example.com'
+                },
+                'links' => { 'self' => '/forest/user/2' },
+                'relationships' => {}
+              }
+            ]
+          }
+        end
+
+        it 'returns match fields for matching records' do
+          result = described_class.decorate_for_search(records_serialized, field_names, search_value)
+
+          expect(result).to eq({
+                                 0 => {
+                                   id: '1',
+                                   search: %w[name email]
+                                 }
+                               })
+        end
+
+        it 'includes ID field in search when ID matches' do
+          search_value = '2'
+
+          result = described_class.decorate_for_search(records_serialized, field_names, search_value)
+
+          expect(result[1][:search]).to include('id')
+        end
+
+        it 'handles multiple matches across different records' do
+          records_serialized['data'][1]['attributes']['name'] = 'Johnny Cash'
+
+          result = described_class.decorate_for_search(records_serialized, field_names, search_value)
+
+          expect(result).to have_key(0)
+          expect(result).to have_key(1)
+          expect(result[0][:search]).to contain_exactly('name', 'email')
+          expect(result[1][:search]).to contain_exactly('name')
+        end
+
+        it 'skips fields with nil values' do
+          records_serialized['data'][0]['attributes']['email'] = nil
+
+          result = described_class.decorate_for_search(records_serialized, field_names, search_value)
+
+          expect(result[0][:search]).to eq(['name'])
+        end
+
+        it 'skips fields with empty string values' do
+          records_serialized['data'][0]['attributes']['email'] = ''
+
+          result = described_class.decorate_for_search(records_serialized, field_names, search_value)
+
+          expect(result[0][:search]).to eq(['name'])
+        end
+      end
+
+      context 'when no matches are found' do
+        let(:records_serialized) do
+          {
+            'data' => [
+              {
+                'type' => 'User',
+                'id' => '1',
+                'attributes' => {
+                  'id' => 1,
+                  'name' => 'Jane Doe',
+                  'email' => 'jane@example.com'
+                },
+                'links' => { 'self' => '/forest/user/1' },
+                'relationships' => {}
+              }
+            ]
+          }
+        end
+
+        it 'returns nil' do
+          result = described_class.decorate_for_search(records_serialized, field_names, search_value)
+
+          expect(result).to be_nil
+        end
+      end
+
+      context 'with invalid record structure' do
+        let(:records_serialized) do
+          {
+            'data' => [
+              {
+                'type' => 'User',
+                'id' => '1',
+                'links' => { 'self' => '/forest/user/1' },
+                'relationships' => {
+                  'claim' => { 'links' => { 'related' => {} } }
+                }
+              }
+            ]
+          }
+        end
+
+        it 'raises ArgumentError with descriptive message' do
+          expect {
+            described_class.decorate_for_search(records_serialized, field_names, search_value)
+          }.to raise_error(ArgumentError, "Missing 'attributes' key in record #{records_serialized['data'][0]}")
+        end
+      end
+    end
+  end
+end

data/spec/requests/actions_controller_spec.rb

@@ -1,6 +1,8 @@
 require 'rails_helper'
 
 describe 'Requesting Actions routes', :type => :request  do
+  subject(:controller) { ForestLiana::ApplicationController.new }
+
   let(:rendering_id) { 13 }
   let(:scope_filters) { {'scopes' => {}, 'team' => {'id' => '1', 'name' => 'Operations'}} }
 
@@ -11,6 +13,16 @@ describe 'Requesting Actions routes', :type => :request  do
 
     ForestLiana::ScopeManager.invalidate_scope_cache(rendering_id)
     allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return(scope_filters)
+
+
+    allow(ForestAdmin::JSONAPI::Serializer)
+      .to receive(:serialize)
+            .and_return(json_out)
+
+    allow(controller)
+      .to receive(:force_utf8_encoding) do |arg|
+      arg
+    end
   end
 
   after(:each) do
@@ -38,6 +50,10 @@ describe 'Requesting Actions routes', :type => :request  do
     }
   }
 
+  let(:record) { Island.first }
+
+  let(:json_out){ { 'data' => [] } }
+
   describe 'hooks' do
     island = ForestLiana.apimap.find {|collection| collection.name.to_s == ForestLiana.name_for(Island)}
 
@@ -504,4 +520,90 @@ describe 'Requesting Actions routes', :type => :request  do
       end
     end
   end
+
+  describe 'serialize model' do
+    it 'should set is_collection and context option correctly' do
+      options = { field: {"Island" => "id,name"} }
+
+      expect(ForestAdmin::JSONAPI::Serializer)
+        .to receive(:serialize) do |obj, opts|
+        expect(obj).to eq(record)
+        expect(opts[:is_collection]).to be(false)
+        expect(opts[:context]).to include(unoptimized: true)
+        json_out
+      end
+
+      expect(controller).to receive(:force_utf8_encoding).with(json_out)
+
+      res = controller.send(:serialize_model, record, options)
+      expect(res).to eq(json_out)
+    end
+  end
+
+  describe 'serialize models' do
+    let(:records) { Island.all }
+
+    context 'when params fields is not present' do
+      it 'merges unoptimized into context' do
+        options = { field: {"Island" => "id,name"}, params: { searchToEdit: 'true' }, context: { foo: 42 } }
+
+        expect(ForestAdmin::JSONAPI::Serializer)
+          .to receive(:serialize) do |objs, opts|
+          expect(objs).to eq(records)
+          expect(opts[:is_collection]).to be(true)
+          expect(opts[:context]).to include(unoptimized: true, foo: 42)
+          json_out
+        end
+
+        res = controller.send(:serialize_models, records, options)
+        expect(res).to eq(json_out)
+      end
+    end
+
+    context 'when params fields is present' do
+      it 'leaves context unchanged' do
+        options = { params: { fields: 'id' }, context: { foo: 1 } }
+
+        expect(ForestAdmin::JSONAPI::Serializer)
+          .to receive(:serialize) do |_, opts|
+          expect(opts[:context]).to eq(foo: 1)
+          json_out
+        end
+
+        controller.send(:serialize_models, records, options)
+      end
+    end
+
+    context 'when params[:search] is present' do
+      it 'adds meta.decorators via DecorationHelper and concatenates smart fields' do
+        options = { params: { search: 'hello' } }
+        fields_searched = ['existing']
+        collection_double = double('collection', string_smart_fields_names: %w[foo bar])
+
+        allow_any_instance_of(ForestLiana::ApplicationController)
+          .to receive(:get_collection)
+                .and_return(collection_double)
+
+        expect(ForestLiana::DecorationHelper)
+          .to receive(:decorate_for_search) do |json, fields, term|
+          expect(json).to eq(json_out)
+          expect(fields).to match_array(%w[existing foo bar])
+          expect(term).to eq('hello')
+          { foo: 'bar' }
+        end
+          .and_return({ foo: 'bar' })
+
+        res = controller.send(:serialize_models, records, options, fields_searched)
+
+        expect(res['meta']).to eq(decorators: { foo: 'bar' })
+        expect(fields_searched).to match_array(%w[existing foo bar])
+      end
+    end
+
+    it 'calls force_utf8_encoding with the final JSON' do
+      options = {}
+      expect(controller).to receive(:force_utf8_encoding).with(json_out)
+      controller.send(:serialize_models, records, options)
+    end
+  end
 end

data/spec/services/forest_liana/has_many_getter_spec.rb

@@ -113,6 +113,95 @@ module ForestLiana
           end
         end
       end
+
+      describe 'compute_includes' do
+        it 'should include has_one relation from association' do
+          expect(subject.includes).to include(:location)
+        end
+
+        it 'should include belongs_to relations from association' do
+          expect(subject.includes).to include(:owner, :cutter, :island, :eponymous_island)
+        end
+
+        it 'should exclude has_many relations' do
+          has_many_associations = Tree.reflect_on_all_associations
+                                      .select { |a| a.macro == :has_many }
+                                      .map(&:name)
+
+          has_many_associations.each do |assoc|
+            expect(subject.includes).not_to include(assoc)
+          end
+        end
+
+        it 'should include all supported associations from association by default' do
+          expected_associations = Tree.reflect_on_all_associations
+                                      .select { |a| [:belongs_to, :has_one, :has_and_belongs_to_many].include?(a.macro) }
+                                      .map(&:name)
+
+          expect(subject.includes).to match_array(expected_associations)
+        end
+
+        it 'should respect fields filter for associations' do
+          params[:fields] = { 'Tree' => 'owner,island' }
+          getter = described_class.new(Island, association, params, user)
+
+          expect(getter.includes).to include(:owner, :island)
+          expect(getter.includes).not_to include(:cutter, :eponymous_island, :location)
+        end
+
+        it 'should exclude Tree associations when models not included' do
+          allow(SchemaUtils).to receive(:model_included?).and_return(false)
+          expect(subject.includes).to be_empty
+        end
+
+        context 'on polymorphic associations' do
+          let(:base_params) do
+            {
+              id: Island.first&.id || 1,
+              association_name: 'trees',
+              page: { size: 15, number: 1 },
+              timezone: 'UTC'
+            }
+          end
+
+          before do
+            # temporarily add a polymorphic association on Tree
+            Tree.class_eval { belongs_to :addressable, polymorphic: true, optional: true }
+
+            allow_any_instance_of(described_class).to receive(:prepare_query).and_return(nil)
+            allow(ForestLiana).to receive(:name_for).and_return('trees')
+          end
+
+          after do
+            %w[addressable].each do |name|
+              Tree._reflections.delete(name)
+              Tree.reflections.delete(name)
+            end
+            %w[addressable addressable= addressable_id addressable_type].each do |m|
+              Tree.undef_method(m) rescue nil
+            end
+          end
+
+          it 'should exclude the polymorphic association when not all target models are includable' do
+            params = base_params.merge(fields: { 'trees' => 'addressable' })
+
+            allow(SchemaUtils).to receive(:model_included?).and_return(true, false)
+
+            getter = described_class.new(Island, association, params, user)
+            expect(getter.includes).to eq([])
+          end
+
+          it 'should include the polymorphic association only when all target models are includable' do
+            params = base_params.merge(fields: { 'trees' => 'addressable' })
+
+            allow(SchemaUtils).to receive(:model_included?).and_return(true, true)
+
+            getter = described_class.new(Island, association, params, user)
+            expect(getter.includes).to contain_exactly(:addressable)
+          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.15.4
+  version: 9.15.6
 platform: ruby
 authors:
 - Sandro Munda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-12 00:00:00.000000000 Z
+date: 2025-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -404,6 +404,7 @@ files:
 - spec/dummy/lib/forest_liana/collections/user.rb
 - spec/dummy/lib/forest_liana/controllers/owner_trees_controller.rb
 - spec/dummy/lib/forest_liana/controllers/owners_controller.rb
+- spec/helpers/forest_liana/decoration_helper_spec.rb
 - spec/helpers/forest_liana/query_helper_spec.rb
 - spec/helpers/forest_liana/schema_helper_spec.rb
 - spec/lib/forest_liana/bootstrapper_spec.rb
@@ -710,6 +711,7 @@ test_files:
 - spec/dummy/lib/forest_liana/collections/user.rb
 - spec/dummy/lib/forest_liana/controllers/owner_trees_controller.rb
 - spec/dummy/lib/forest_liana/controllers/owners_controller.rb
+- spec/helpers/forest_liana/decoration_helper_spec.rb
 - spec/helpers/forest_liana/query_helper_spec.rb
 - spec/helpers/forest_liana/schema_helper_spec.rb
 - spec/lib/forest_liana/bootstrapper_spec.rb