forest_liana 9.15.1 → 9.15.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c700fa60cbdb6da1e131e2e041d7bec408052bf6ce50304e51f2e6f6525e8d8
-  data.tar.gz: fdc53e76cf29afabdd6b18ec6a3279bd0e9bec3b467e8f8b16cb6cbb7dda87aa
+  metadata.gz: 6c293cc19d5273766a98fcc556bb07bcdd9dea63cd604aeee9352055556b9994
+  data.tar.gz: fe841959936a030dc0989da2645ce9db9a74237bf86d7028c2cc4c7de27fece8
 SHA512:
-  metadata.gz: fe65c60f75a320f96e826dc7b93e25106d0958c62f1157212496ba57eef33e9be08776ab104200b2eb9d7e772fc1f2cae58f811f2033d57e2969e877cf3dbc64
-  data.tar.gz: bf3c7eb151213fb126ef896d040369c2a3c65500e8e2ecbd292c06cbb016939fc607e295db9fc719b09e428c52ad7f4462bee211f7f532794be0d4895ef2d50d
+  metadata.gz: b4ab70690f0da9891d2e5484ad33548e443bf5d72cf0edbc24caae74fe6214a2e3d9f10489ebdb331b907809a6d19cd2cfdd1631c80ed5c0aff4156a5e666326
+  data.tar.gz: bb3272e7f6ae11f3538f15ac0cb280df67015ac940d1734d8cc5d04f9ad1168b1e09ad9073e3b85cfef0c936d7393db70a90973e14a34d0e367584e46f3a4311

data/app/controllers/forest_liana/application_controller.rb

@@ -156,10 +156,12 @@ module ForestLiana
         params_fields_hash.inject({}) do |fields, param_field|
           relation_name = param_field[0]
           relation_fields = param_field[1]
+          forest_collection = ForestLiana.apimap.find { |collection| collection.name.to_s == model.to_s.gsub('::', '__') }
+          smart_relations = forest_collection.fields_smart_belongs_to
 
           if relation_name == ForestLiana.name_for(model)
             fields[relation_name] = relation_fields
-          else
+          elsif model.reflect_on_association(relation_name.to_sym)
             model_association = model.reflect_on_association(relation_name.to_sym)
             if model_association
               model_name = ForestLiana.name_for(model_association.klass)
@@ -173,7 +175,14 @@ module ForestLiana
                 fields[model_name] = relation_fields
               end
             end
+          else
+            smart_relations.each do |smart_relation|
+              if smart_relation[:field].to_s == relation_name
+                fields[smart_relation[:reference].split('.').first] = relation_fields
+              end
+            end
           end
+
           fields
         end
       else

data/app/serializers/forest_liana/serializer_factory.rb

@@ -47,6 +47,81 @@ module ForestLiana
       end
     end
 
+    # duplicate method from Serializer
+    ForestAdmin::JSONAPI::Serializer.singleton_class.send(:define_method, :find_recursive_relationships) do |root_object, root_inclusion_tree, results, options|
+      ActiveSupport::Notifications.instrument(
+        'render.jsonapi_serializers.find_recursive_relationships',
+        {class_name: root_object.class.name},
+        ) do
+        root_inclusion_tree.each do |attribute_name, child_inclusion_tree|
+          next if attribute_name == :_include
+
+          serializer = ForestAdmin::JSONAPI::Serializer.find_serializer(root_object, options)
+          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)
+
+            raise ForestAdmin::JSONAPI::Serializer::InvalidIncludeError.new(
+              "'#{attribute_name}' is not a valid include.  Did you mean '#{expected_name}' ?"
+            )
+          end
+
+          next if object.nil?
+
+          objects = is_collection ? object : [object]
+          if child_inclusion_tree[:_include] == true
+            objects.each do |obj|
+              obj_serializer = ForestAdmin::JSONAPI::Serializer.find_serializer(obj, options)
+              key = [obj_serializer.type, obj_serializer.id]
+
+              current_child_includes = []
+              inclusion_names = child_inclusion_tree.keys.reject { |k| k == :_include }
+              inclusion_names.each do |inclusion_name|
+                if child_inclusion_tree[inclusion_name][:_include]
+                  current_child_includes << inclusion_name
+                end
+              end
+
+              current_child_includes += results[key] && results[key][:include_linkages] || []
+              current_child_includes.uniq!
+              results[key] = {object: obj, include_linkages: current_child_includes}
+            end
+          end
+
+          if !child_inclusion_tree.empty?
+            objects.each do |obj|
+              find_recursive_relationships(obj, child_inclusion_tree, results, options)
+            end
+          end
+        end
+      end
+      nil
+    end
+
     def initialize(is_smart_collection = false)
       @is_smart_collection = is_smart_collection
     end
@@ -136,28 +211,46 @@ module ForestLiana
           data = {}
           self.class.to_one_associations.each do |attribute_name, attr_data|
             relation = object.class.reflect_on_all_associations.find { |a| a.name == attribute_name }
-
             next if !should_include_attr?(attribute_name, attr_data)
 
-            unless relation.nil? || (relation.respond_to?(:polymorphic?) && relation.polymorphic?)
-              relation_class_name = ForestLiana.name_for(relation.klass).demodulize
-
-              if object.respond_to?(relation.foreign_key.to_sym) &&
-                @options[:fields][relation_class_name]&.size == 1 &&
-                @options[:fields][relation_class_name]&.include?(relation.klass.primary_key.to_sym)
-
-                attr_data[:attr_or_block] = proc {
-                  foreign_key_value = object.send(relation.foreign_key.to_sym)
-                  foreign_key_value.nil? ? nil : relation.klass.new(relation.klass.primary_key => foreign_key_value)
-                }
+            if relation && relation.belongs_to? && relation.polymorphic?.nil?
+              reflection_primary_key = relation.options[:primary_key]&.to_sym || :id
+              klass_primary_key = relation.klass.primary_key.to_sym
+
+              if reflection_primary_key != klass_primary_key
+                data[attribute_name] = attr_data.merge({
+                                                         attr_or_block: proc {
+                                                           relation.klass.find_by(reflection_primary_key => object.send(relation.foreign_key))
+                                                         }
+                                                       })
+                next
               end
             end
 
             data[attribute_name] = attr_data
           end
+
           data
         end
 
+        def should_include_attr?(attribute_name, attr_data)
+          collection = self.type
+
+          unless @options.dig(:context, :unoptimized)
+            return false unless @options[:fields][collection]&.include?(attribute_name.to_sym)
+          end
+
+          # Allow "if: :show_title?" and "unless: :hide_title?" attribute options.
+          if_method_name = attr_data[:options][:if]
+          unless_method_name = attr_data[:options][:unless]
+          formatted_attribute_name = format_name(attribute_name).to_sym
+          show_attr = true
+          show_attr &&= send(if_method_name) if if_method_name
+          show_attr &&= !send(unless_method_name) if unless_method_name
+          show_attr &&= @_fields[type.to_s].include?(formatted_attribute_name) if @_fields[type.to_s]
+          show_attr
+        end
+
         private
 
         def intercom_integration?

data/app/services/forest_liana/resources_getter.rb

@@ -74,55 +74,9 @@ module ForestLiana
         end
       end
 
-      preload_cross_database_associations(records, preload_loads)
-
       records
     end
 
-    def preload_cross_database_associations(records, preload_loads)
-      preload_loads.each do |association_name|
-        association = @resource.reflect_on_association(association_name)
-        next unless separate_database?(@resource, association)
-
-        columns = columns_for_cross_database_association(association_name)
-        if association.macro == :belongs_to
-          foreign_key = association.foreign_key
-          primary_key = association.klass.primary_key
-
-          ids = records.map { |r| r.public_send(foreign_key) }.compact.uniq
-          next if ids.empty?
-
-          associated = association.klass.where(primary_key => ids)
-                                  .select(columns)
-                                  .index_by { |record| record.public_send(primary_key) }
-
-          records.each do |record|
-            record.define_singleton_method(association_name) do
-              associated[record.send(foreign_key.to_sym)] || nil
-            end
-          end
-        end
-
-        if association.macro == :has_one
-          foreign_key = association.foreign_key
-          primary_key = association.active_record_primary_key
-
-          ids = records.map { |r| r.public_send(primary_key) }.compact.uniq
-          next if ids.empty?
-
-          associated = association.klass.where(foreign_key => ids)
-                                  .select(columns)
-                                  .index_by { |record| record.public_send(foreign_key.to_sym) }
-
-          records.each do |record|
-            record.define_singleton_method(association_name) do
-              associated[record.send(primary_key.to_sym)] || nil
-            end
-          end
-        end
-      end
-    end
-
     def columns_for_cross_database_association(association_name)
       association = @resource.reflect_on_association(association_name)
 

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "9.15.1"
+  VERSION = "9.15.3"
 end

data/spec/requests/resources_spec.rb

@@ -124,18 +124,7 @@ describe 'Requesting Tree resources', :type => :request  do
           "included" => [{
             "type" => "Location",
             "id" => "1",
-            "attributes" => include(
-              "id" => 1,
-              "created_at" => nil,
-              "updated_at" => nil,
-              "coordinates" => nil
-            ),
-            "links" => { "self" => "/forest/location/1" },
-            "relationships" => {
-              "island" => {
-                "links" => { "related" => {} }
-              }
-            }
+            "links" => { "self" => "/forest/location/1" }
           }]
         })
       end

data/spec/services/forest_liana/serializer_factory_spec.rb

@@ -5,27 +5,6 @@ module ForestLiana
       let(:island) { Island.create!(name: 'TestIsland') }
       let(:tree) { Tree.create!(name: 'TestTree', island: island, owner: user) }
 
-      it 'simulates has_one relation with only primary key' do
-        factory = described_class.new
-        serializer_class = factory.serializer_for(Tree)
-
-        serializer_class.send(:has_one, :island) { }
-
-        instance = serializer_class.new(tree, fields: {
-          'Island' => [:id],
-          'Tree' => [:island]
-        })
-
-        relationships = instance.send(:has_one_relationships)
-        expect(relationships).to have_key(:island)
-        relation_data = relationships[:island]
-        expect(relation_data[:attr_or_block]).to be_a(Proc)
-        model = relation_data[:attr_or_block].call
-
-        expect(model).to be_a(Island)
-        expect(model.id).to eq(island.id)
-      end
-
       it 'returns nil if foreign key is nil' do
         tree_without_island = Tree.create!(name: 'NoIslandTree', island_id: nil, owner: user)
 

metadata

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