forest_liana 9.20.1 → 9.20.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e6590ae4597f44757af9a98c3f4d8ba9e83652eedd857f45aeb1fe365e8a8ae
-  data.tar.gz: 5aa5f3150171dd65dac411007c311b9cb5409c9eb97d1a415d31e908001b0d34
+  metadata.gz: be12c6b12347b9f674f52eb7f52b41294717436fae76926129d02b6194d6a116
+  data.tar.gz: 3a2d7c0a34e7cadbfc40d70b4385d23ffe703de619f9c28b49a10af86a23a8f5
 SHA512:
-  metadata.gz: 6d848b970f6f68edd2a162f40e546740878c6fc7e2b298a3c494f6641fce908b41e2412a9e3457d13edef7d6433ce9f5704b77604851b2fd7aeca5eb60cfe691
-  data.tar.gz: 2828ff99f57028970cc2ec4e1662b70203d0d077ca0bbb45350dd4d29d09bffaffd1ef907b923e666cfc28704f97db62358bdf6709cf4b7c16bac822cd1afa15
+  metadata.gz: 3c32654d08132350f85a8313b7ef296838782d72e367509c4283990fb7fda261e453629e0b44f268ece649ae2889ec67dea07c31a6b4b3f2f799178367c016d4
+  data.tar.gz: 205dad627f2752573f9f8e9c9a17e8e5a1ec3ad2260bad68a041b38d783060ee5f399950928a8b7f6ea8bf3b450d23878ec5fac7247d7c5e067b323348b4acf0

data/app/services/forest_liana/base_getter.rb

@@ -51,10 +51,8 @@ module ForestLiana
     def separate_database?(resource, association)
       return false if SchemaUtils.polymorphic?(association)
 
-      target_model_connection = association.klass.connection
-      target_model_database = target_model_connection.current_database if target_model_connection.respond_to? :current_database
-      resource_connection = resource.connection
-      resource_database = resource_connection.current_database if resource_connection.respond_to? :current_database
+      target_model_database = association.klass.connection.pool.db_config.database
+      resource_database = resource.connection.pool.db_config.database
 
       target_model_database != resource_database
     end

data/app/services/forest_liana/schema_adapter.rb

@@ -266,6 +266,9 @@ module ForestLiana
             }
 
             collection.fields = collection.fields.reject do |field|
+              # NOTICE: A primary key column must survive; a type column is never one.
+              next false if field[:is_primary_key]
+
               field[:field] == association.foreign_key || field[:field] == association.foreign_type
             end
           # NOTICE: Delete the association if the targeted model is excluded.
@@ -274,7 +277,8 @@ module ForestLiana
               x[:field] == association.foreign_key
             end
 
-            collection.fields.delete(field) if field
+            # NOTICE: A primary key column must survive, even as an excluded association's FK.
+            collection.fields.delete(field) if field && !field[:is_primary_key]
           # NOTICE: The foreign key exists, so it's a belongsTo relationship.
           elsif (field = column_association(collection, association)) &&
             [:has_one, :belongs_to].include?(association.macro)

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "9.20.1"
+  VERSION = "9.20.3"
 end

data/spec/services/forest_liana/resources_getter_spec.rb

@@ -83,26 +83,6 @@ module ForestLiana
       let(:resource) { Product }
       let(:fields) { { resource.name => 'id,name,manufacturer', 'manufacturer' => 'name' } }
 
-      shared_context 'resource current_database' do
-        before do
-          connection = resource.connection
-
-          def connection.current_database
-            'db/test.sqlite3'
-          end
-        end
-
-        after do
-          resource.connection.singleton_class.remove_method(:current_database)
-        end
-      end
-
-      shared_examples 'left outer join' do
-        it 'should perform a left outer join with the association' do
-          expect(getter.perform.to_sql).to match(/LEFT OUTER JOIN "manufacturers"/)
-        end
-      end
-
       shared_examples 'records' do
         it 'should get only the expected records' do
           getter.perform
@@ -117,40 +97,38 @@ module ForestLiana
         end
       end
 
-      context 'when the connections do not support current_database' do
-        include_examples 'left outer join'
+      context 'when the included association is in the same database' do
+        it 'performs a left outer join with the association' do
+          expect(getter.perform.to_sql).to match(/LEFT OUTER JOIN "manufacturers"/)
+        end
+
         include_examples 'records'
       end
 
-      context 'when the included association uses a different database connection' do
+      context 'when the included association is in a different database' do
         let(:fields) { { resource.name => 'id,name,driver', 'driver' => 'firstname' } }
 
-        before do
-          association_connection = resource.reflect_on_association(:driver).klass.connection
-
-          def association_connection.current_database
-            'db/different_test.sqlite3'
-          end
-        end
-
-        after do
-          resource.reflect_on_association(:driver).klass.connection.singleton_class.remove_method(:current_database)
-        end
-
-        include_context 'resource current_database'
-
-        include_examples 'records'
-
         it 'does not perform a left outer join with the association' do
           expect(getter.perform.to_sql).not_to match(/LEFT OUTER JOIN "drivers"/)
         end
+
+        include_examples 'records'
       end
 
-      context 'when the included association uses the same database connection' do
-        include_context 'resource current_database'
+      it 'resolves the database without issuing a SQL query' do
+        getter
 
-        include_examples 'left outer join'
-        include_examples 'records'
+        queries = []
+        subscriber = ActiveSupport::Notifications.subscribe('sql.active_record') do |*, payload|
+          queries << payload[:sql] unless payload[:name] == 'SCHEMA' || payload[:cached]
+        end
+        begin
+          getter.send(:separate_database?, Product, Product.reflect_on_association(:manufacturer))
+        ensure
+          ActiveSupport::Notifications.unsubscribe(subscriber)
+        end
+
+        expect(queries).to be_empty
       end
     end
 

data/test/services/forest_liana/schema_adapter_test.rb

@@ -86,6 +86,62 @@ module ForestLiana
       ForestLiana.apimap << original if original
     end
 
+    test 'a primary key column that is also the foreign key of an excluded association is kept' do
+      excluded_models = ForestLiana.excluded_models
+      name = ForestLiana.name_for(BelongsToField)
+      original = ForestLiana.apimap.find { |c| c.name.to_s == name }
+      ForestLiana.apimap.delete(original) if original
+      ForestLiana.excluded_models = [ForestLiana.name_for(HasOneField)]
+      BelongsToField.define_singleton_method(:primary_key) { 'has_one_field_id' }
+
+      schema = SchemaAdapter.new(BelongsToField).perform
+      field = schema.fields.find { |f| f[:field] == 'has_one_field_id' }
+
+      refute_nil field, 'the primary key column must not be deleted'
+      assert_equal true, field[:is_primary_key]
+    ensure
+      BelongsToField.singleton_class.send(:remove_method, :primary_key)
+      ForestLiana.excluded_models = excluded_models
+      rebuilt = ForestLiana.apimap.find { |c| c.name.to_s == name }
+      ForestLiana.apimap.delete(rebuilt) if rebuilt
+      ForestLiana.apimap << original if original
+    end
+
+    test 'an ordinary foreign key of an excluded association is still deleted' do
+      excluded_models = ForestLiana.excluded_models
+      name = ForestLiana.name_for(BelongsToField)
+      original = ForestLiana.apimap.find { |c| c.name.to_s == name }
+      ForestLiana.apimap.delete(original) if original
+      ForestLiana.excluded_models = [ForestLiana.name_for(HasOneField)]
+
+      schema = SchemaAdapter.new(BelongsToField).perform
+
+      assert_nil schema.fields.find { |f| f[:field] == 'has_one_field_id' }
+    ensure
+      ForestLiana.excluded_models = excluded_models
+      rebuilt = ForestLiana.apimap.find { |c| c.name.to_s == name }
+      ForestLiana.apimap.delete(rebuilt) if rebuilt
+      ForestLiana.apimap << original if original
+    end
+
+    test 'a primary key column that is also a polymorphic foreign key is kept' do
+      name = ForestLiana.name_for(PolymorphicField)
+      original = ForestLiana.apimap.find { |c| c.name.to_s == name }
+      ForestLiana.apimap.delete(original) if original
+      PolymorphicField.define_singleton_method(:primary_key) { 'has_one_field_id' }
+
+      schema = SchemaAdapter.new(PolymorphicField).perform
+      field = schema.fields.find { |f| f[:field] == 'has_one_field_id' }
+
+      refute_nil field, 'the primary key column must not be rejected'
+      assert_equal true, field[:is_primary_key]
+    ensure
+      PolymorphicField.singleton_class.send(:remove_method, :primary_key)
+      rebuilt = ForestLiana.apimap.find { |c| c.name.to_s == name }
+      ForestLiana.apimap.delete(rebuilt) if rebuilt
+      ForestLiana.apimap << original if original
+    end
+
     test 'belongsTo relationship' do
       schema = SchemaAdapter.new(BelongsToField).perform
       fields = schema.fields.select do |field|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_liana
 version: !ruby/object:Gem::Version
-  version: 9.20.1
+  version: 9.20.3
 platform: ruby
 authors:
 - Sandro Munda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-23 00:00:00.000000000 Z
+date: 2026-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails