forest_liana 9.15.4 → 9.15.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01b3a5629878eddd5cfdeea4bcb0fadcdd46c5211ac3bf327d8cda5cc6ecb068
-  data.tar.gz: a05b24374ac64efca265824dcd69167c690b1a7bff67fbafc06ab9d497fa2531
+  metadata.gz: cfe8bf0157f9d29d2dcc9131bc3e5ab3ad46e487a7a1d0c931fb6d9702e3f699
+  data.tar.gz: a58e6a4880d3f5640bdb98d2ac188090ba0b0c68e5cdbb69492b1d53c046b07a
 SHA512:
-  metadata.gz: 89fcfaf157e5cc76277e85eba8ad01ba92450e8f9081a8602881ae5d7b20bdd23e11b0029ad144000b7b886f081d2f5f0a7444084990df1678a44d471dd94fd8
-  data.tar.gz: b02ae1262881d03d225f7795e92e26764a738343ba8880b36ed13d44521a3d09686db209dda8a4ecfa260afe3990859ee2eff348892f74891d7e60b11791fcd1
+  metadata.gz: 3cc3acf083ea28eb0562ff90eb662d77ebbf52d7a5f910cfe5355211f01135a9b383e45b1f2b21d35944c20a38f2a0af04aaded4028c2b00192f7791f8d87e3f
+  data.tar.gz: 13f80d33d32895478d31ce251dd6e73ceab910fb6420eaeb292011b00987987a0d629b7e35089c4c1c2300c9512dddf26a9f075a4bc37493cf1a9360132f954d

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