forest_liana 9.15.2 → 9.15.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d472c9569d143414f26b2f574fb1a645eabb4cae94ada16510ea776609d78e7
-  data.tar.gz: d5ec3a959fea0e578abdd8667ec2c062e125aa663e241b27834ad668effa74c7
+  metadata.gz: 01b3a5629878eddd5cfdeea4bcb0fadcdd46c5211ac3bf327d8cda5cc6ecb068
+  data.tar.gz: a05b24374ac64efca265824dcd69167c690b1a7bff67fbafc06ab9d497fa2531
 SHA512:
-  metadata.gz: e804289358deb668cab2b0dcd23027a18b0cc67fa27a490ae7cb405ef62c29a269df58f6d9692651782dce51c41ae09dcbf692686cdeea8dc4e0f22165a37334
-  data.tar.gz: 4ff713e235b574d038af42d11f6e84c6e56a9cca6dfd738f432cf16259a64cd8a1059b97f4923a0304b19b2f1cea15cb32d066c868889494b9f16d38ebe69c33
+  metadata.gz: 89fcfaf157e5cc76277e85eba8ad01ba92450e8f9081a8602881ae5d7b20bdd23e11b0029ad144000b7b886f081d2f5f0a7444084990df1678a44d471dd94fd8
+  data.tar.gz: b02ae1262881d03d225f7795e92e26764a738343ba8880b36ed13d44521a3d09686db209dda8a4ecfa260afe3990859ee2eff348892f74891d7e60b11791fcd1

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)
@@ -156,10 +158,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 +177,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[relation_name] = 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
@@ -131,6 +206,51 @@ module ForestLiana
           ret
         end
 
+        def has_one_relationships
+          return {} if self.class.to_one_associations.nil?
+          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)
+
+            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.2"
+  VERSION = "9.15.4"
 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

metadata

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