forest_liana 9.15.3 → 9.15.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c293cc19d5273766a98fcc556bb07bcdd9dea63cd604aeee9352055556b9994
-  data.tar.gz: fe841959936a030dc0989da2645ce9db9a74237bf86d7028c2cc4c7de27fece8
+  metadata.gz: cfe8bf0157f9d29d2dcc9131bc3e5ab3ad46e487a7a1d0c931fb6d9702e3f699
+  data.tar.gz: a58e6a4880d3f5640bdb98d2ac188090ba0b0c68e5cdbb69492b1d53c046b07a
 SHA512:
-  metadata.gz: b4ab70690f0da9891d2e5484ad33548e443bf5d72cf0edbc24caae74fe6214a2e3d9f10489ebdb331b907809a6d19cd2cfdd1631c80ed5c0aff4156a5e666326
-  data.tar.gz: bb3272e7f6ae11f3538f15ac0cb280df67015ac940d1734d8cc5d04f9ad1168b1e09ad9073e3b85cfef0c936d7393db70a90973e14a34d0e367584e46f3a4311
+  metadata.gz: 3cc3acf083ea28eb0562ff90eb662d77ebbf52d7a5f910cfe5355211f01135a9b383e45b1f2b21d35944c20a38f2a0af04aaded4028c2b00192f7791f8d87e3f
+  data.tar.gz: 13f80d33d32895478d31ce251dd6e73ceab910fb6420eaeb292011b00987987a0d629b7e35089c4c1c2300c9512dddf26a9f075a4bc37493cf1a9360132f954d

data/app/controllers/forest_liana/application_controller.rb

@@ -40,6 +40,8 @@ module ForestLiana
 
     def serialize_model(record, options = {})
       options[:is_collection] = false
+      options[:context] = { unoptimized: true }.merge(options[:context] || {})
+
       json = ForestAdmin::JSONAPI::Serializer.serialize(record, options)
 
       force_utf8_encoding(json)
@@ -178,7 +180,7 @@ module ForestLiana
           else
             smart_relations.each do |smart_relation|
               if smart_relation[:field].to_s == relation_name
-                fields[smart_relation[:reference].split('.').first] = relation_fields
+                fields[relation_name] = relation_fields
               end
             end
           end

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.3"
+  VERSION = "9.15.5"
 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.3
+  version: 9.15.5
 platform: ruby
 authors:
 - Sandro Munda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-08 00:00:00.000000000 Z
+date: 2025-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails