forest_liana 9.15.5 → 9.15.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfe8bf0157f9d29d2dcc9131bc3e5ab3ad46e487a7a1d0c931fb6d9702e3f699
-  data.tar.gz: a58e6a4880d3f5640bdb98d2ac188090ba0b0c68e5cdbb69492b1d53c046b07a
+  metadata.gz: d693ce27b46138de7814e1d7486d4d67b8e094ea57ecdaec552ab557ca870438
+  data.tar.gz: d236006d4441662e39102eb6791e8713754097b0ec1620f799557a6513c79531
 SHA512:
-  metadata.gz: 3cc3acf083ea28eb0562ff90eb662d77ebbf52d7a5f910cfe5355211f01135a9b383e45b1f2b21d35944c20a38f2a0af04aaded4028c2b00192f7791f8d87e3f
-  data.tar.gz: 13f80d33d32895478d31ce251dd6e73ceab910fb6420eaeb292011b00987987a0d629b7e35089c4c1c2300c9512dddf26a9f075a4bc37493cf1a9360132f954d
+  metadata.gz: 71f50a75e497a526837a9418f05ee8b8c361d1685875df78b29c88883d69da7766814f6e3f0b372a2edfdade2f2341c8115f8da2368dc968c9e3e00e3cd4bbdc
+  data.tar.gz: 301ebd315a041666583fcd2386c578850aaf627e8c4f6a9cfe1e5ca194abec82f9eb98777a08d1afc343e5fe54d30f68097c51c4fa88dadf4701c0618535b835

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/serializers/forest_liana/serializer_factory.rb

@@ -60,28 +60,20 @@ module ForestLiana
           unformatted_attr_name = serializer.unformat_name(attribute_name).to_sym
           object = nil
           is_collection = false
-          is_valid_attr = false
           if serializer.has_one_relationships.has_key?(unformatted_attr_name)
             # only added this condition
             if root_object.class.reflect_on_association(unformatted_attr_name)&.polymorphic?
               options[:context][:unoptimized] = true
             end
 
-            is_valid_attr = true
             attr_data = serializer.has_one_relationships[unformatted_attr_name]
             object = serializer.has_one_relationship(unformatted_attr_name, attr_data)
           elsif serializer.has_many_relationships.has_key?(unformatted_attr_name)
-            is_valid_attr = true
             is_collection = true
             attr_data = serializer.has_many_relationships[unformatted_attr_name]
             object = serializer.has_many_relationship(unformatted_attr_name, attr_data)
           end
 
-          if !is_valid_attr
-            raise ForestAdmin::JSONAPI::Serializer::InvalidIncludeError.new(
-              "'#{attribute_name}' is not a valid include.")
-          end
-
           if attribute_name != serializer.format_name(attribute_name)
             expected_name = serializer.format_name(attribute_name)
 

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "9.15.5"
+  VERSION = "9.15.7"
 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/requests/resources_spec.rb

@@ -167,6 +167,52 @@ describe 'Requesting Tree resources', :type => :request  do
       end
     end
   end
+
+  describe 'csv' do
+    it 'should return CSV with correct headers and data' do
+      params = {
+        fields: { 'Tree' => 'id,name,owner', 'owner' => 'name'},
+        page: { 'number' => '1', 'size' => '10' },
+        searchExtended: '0',
+        sort: '-id',
+        timezone: 'Europe/Paris',
+        header: 'id,name,owner',
+      }
+      get '/forest/Tree.csv', params: params, headers: headers
+
+      expect(response.status).to eq(200)
+      expect(response.headers['Content-Type']).to include('text/csv')
+      expect(response.headers['Content-Disposition']).to include('attachment')
+
+      csv_content = response.body
+      csv_lines = csv_content.split("\n")
+
+      expect(csv_lines.first).to eq(params[:header])
+      expect(csv_lines[1]).to eq('1,Lemon Tree,Michel')
+    end
+
+    it 'returns CSV with only requested fields and ignores optional relation' do
+      params = {
+        fields: { 'Tree' => 'id,name', 'owner' => 'name'},
+        page: { 'number' => '1', 'size' => '10' },
+        searchExtended: '0',
+        sort: '-id',
+        timezone: 'Europe/Paris',
+        header: 'id,name',
+      }
+      get '/forest/Tree.csv', params: params, headers: headers
+
+      expect(response.status).to eq(200)
+      expect(response.headers['Content-Type']).to include('text/csv')
+      expect(response.headers['Content-Disposition']).to include('attachment')
+
+      csv_content = response.body
+      csv_lines = csv_content.split("\n")
+
+      expect(csv_lines.first).to eq(params[:header])
+      expect(csv_lines[1]).to eq('1,Lemon Tree')
+    end
+  end
 end
 
 describe 'Requesting User resources', :type => :request  do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_liana
 version: !ruby/object:Gem::Version
-  version: 9.15.5
+  version: 9.15.7
 platform: ruby
 authors:
 - Sandro Munda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-25 00:00:00.000000000 Z
+date: 2025-08-29 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