fix: enable unoptimized mode in serializer when searchToEdit flag is set (#753)

close #751

Author: matthv

app/controllers/forest_liana/application_controller.rb

@@ -49,6 +49,10 @@ def serialize_model(record, options = {})
 
     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 @@ def serialize_models(records, options = {}, fields_searched = [])
       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

app/helpers/forest_liana/decoration_helper.rb

@@ -14,6 +14,10 @@ def self.detect_match_and_decorate record, index, field_name, value, search_valu
     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

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' => '[email protected]'
+          },
+          '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) { '[email protected]' }
+
+        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' => '[email protected]'
+                },
+                'links' => { 'self' => '/forest/user/1' },
+                'relationships' => {}
+              },
+              {
+                'type' => 'User',
+                'id' => '2',
+                'attributes' => {
+                  'id' => 2,
+                  'name' => 'Jane Smith',
+                  'email' => '[email protected]'
+                },
+                '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' => '[email protected]'
+                },
+                '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

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 @@
 
     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 @@
     }
   }
 
+  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 @@
       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