forest_liana 9.12.2 → 9.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 758e323d04ac55ca40f00c3d77ccff83f2b12609ee13d82e9dba8bc785b8ed98
-  data.tar.gz: 5cd38330c38e58fa252d160d52cdf0635116f75bb99112886991380bf35ea72c
+  metadata.gz: 133660170841c0069ffdc0da3e2a4918e4147f417eae55c87b79bb300d9924b0
+  data.tar.gz: eba503c46d489b6f6a4e81f26764f284574db290aed180755c6ca33841fc8b19
 SHA512:
-  metadata.gz: 7289eb530fb56e1c0f1a70c25b61c3ed92d69fbc34fc437e730e7ece1a63e973f84b257fbb26543e9dd18405890e00dc5c6365efcccbc742e644c560fee07ef1
-  data.tar.gz: fb211dc081537bb5d8a8900867cc5264c74829b0a83e31f0a378d270f3b2dd0c73c5f05e3088da1919922517951ee274b9c67a6f422fe312d6e2dcdc6799e788
+  metadata.gz: a1b5122e4700ae49500fbfc7b7c1060561e3a73cdfe3c980f946453c54eac0fa0c0982914b2ffcb3a18710d9e5c4fddb0cc7b6a12f18feca424d64067987691d
+  data.tar.gz: 4b4183d21184e1986ca78158f7d6e99aae06ea6767292448ddb1bc29b00f3fe2862000d9c642eb8b8c84e4ce19166778a5fa5e3439cdac1c33e925d2f0ce988f

data/app/serializers/forest_liana/serializer_factory.rb

@@ -118,12 +118,6 @@ module ForestLiana
 
           if ret[:href].blank?
             begin
-              if @options[:include].try(:include?, attribute_name.to_s) &&
-                !SchemaHelper.is_smart_field?(object.class, attribute_name.to_s)
-
-                object.send(attribute_name)
-              end
-
               SchemaUtils.many_associations(object.class).each do |a|
                 if a.name == attribute_name
                   ret[:href] = "/forest/#{ForestLiana.name_for(object.class)}/#{object.id}/relationships/#{attribute_name}"
@@ -137,6 +131,30 @@ 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)
+
+            unless relation.polymorphic?
+              relation_class_name = ForestLiana.name_for(relation.klass).demodulize
+
+              if object.send(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 {  relation.klass.new(relation.klass.primary_key => object.send(relation.foreign_key.to_sym)) }
+              end
+            end
+
+            data[attribute_name] = attr_data
+          end
+          data
+        end
+
         private
 
         def intercom_integration?

data/app/services/forest_liana/base_getter.rb

@@ -19,13 +19,14 @@ module ForestLiana
 
     def compute_includes
       @includes = ForestLiana::QueryHelper.get_one_association_names_symbol(@resource)
+      @optional_includes = []
     end
 
-    def optimize_record_loading(resource, records)
+    def optimize_record_loading(resource, records, force_preload = true)
       polymorphic, preload_loads = analyze_associations(resource)
-      result = records.eager_load(@includes.uniq - preload_loads - polymorphic)
+      result = records.eager_load(@includes.uniq - preload_loads - polymorphic - @optional_includes)
 
-      result = result.preload(preload_loads) if Rails::VERSION::MAJOR >= 7
+      result = result.preload(preload_loads) if Rails::VERSION::MAJOR >= 7 && force_preload
 
       result
     end

data/app/services/forest_liana/has_many_getter.rb

@@ -37,6 +37,8 @@ module ForestLiana
     private
 
     def compute_includes
+      @optional_includes = []
+
       @includes = @association.klass
         .reflect_on_all_associations
         .select do |association|

data/app/services/forest_liana/resources_getter.rb

@@ -31,16 +31,16 @@ module ForestLiana
 
     def perform
       polymorphic_association, preload_loads = analyze_associations(@resource)
-      includes = @includes.uniq - polymorphic_association - preload_loads
+      includes = @includes.uniq - polymorphic_association - preload_loads - @optional_includes
       has_smart_fields =  @params[:fields][@collection_name].split(',').any? do |field|
         ForestLiana::SchemaHelper.is_smart_field?(@resource, field)
       end
 
       if includes.empty? || has_smart_fields
-        @records = optimize_record_loading(@resource, @records)
+        @records = optimize_record_loading(@resource, @records, false)
       else
         select = compute_select_fields
-        @records = optimize_record_loading(@resource, @records).references(includes).select(*select)
+        @records = optimize_record_loading(@resource, @records, false).references(includes).select(*select)
       end
 
       @records
@@ -55,31 +55,115 @@ module ForestLiana
     end
 
     def records
-      @records.offset(offset).limit(limit).to_a
+      records = @records.offset(offset).limit(limit).to_a
+
+      polymorphic_association, preload_loads = analyze_associations(@resource)
+      if polymorphic_association && Rails::VERSION::MAJOR >= 7
+        # TODO
+      end
+
+      preload_cross_database_associations(records, preload_loads)
+
+      records
     end
 
-    def compute_includes
-      associations_has_one = ForestLiana::QueryHelper.get_one_associations(@resource)
+    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
 
-      includes = associations_has_one.map(&:name)
-      includes_for_smart_search = []
+          ids = records.map { |r| r.public_send(foreign_key) }.compact.uniq
+          next if ids.empty?
 
-      if @collection && @collection.search_fields
-        includes_for_smart_search = @collection.search_fields
-                                               .select { |field| field.include? '.' }
-                                               .map { |field| field.split('.').first.to_sym }
+          associated = association.klass.where(primary_key => ids)
+                                  .select(columns)
+                                  .index_by { |record| record.public_send(primary_key) }
 
-        includes_has_many = SchemaUtils.many_associations(@resource)
-                                       .select { |association| SchemaUtils.model_included?(association.klass) }
-                                       .map(&:name)
+          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?
 
-        includes_for_smart_search = includes_for_smart_search & includes_has_many
+          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)
+      return [:id] unless @params[:fields].present?
+
+      fields = @params[:fields][association_name.to_s]
+      return [:id] unless fields
+
+      base_fields = fields.split(',').map(&:strip).map(&:to_sym) | [:id]
+
+      association = @resource.reflect_on_association(association_name)
+      extra_key = association.foreign_key
+
+      # Add the foreign key used for the association to ensure it's available in the preloaded records
+      # This is necessary for has_one associations, without it calling record.public_send(foreign_key) would raise a "missing attribute" error
+      base_fields << extra_key if association.macro == :has_one
+
+      base_fields.uniq
+    end
+
+    def compute_includes
+      associations_has_one = ForestLiana::QueryHelper.get_one_associations(@resource)
+      @optional_includes = []
       if @field_names_requested
+        includes = associations_has_one.map do |association|
+          association_name = association.name.to_s
+
+          if @params[:fields].key?(association_name) &&
+            @params[:fields][association_name].split(',').size == 1 &&
+            @params[:fields][association_name].split(',').include?(association.klass.primary_key)
+
+            @field_names_requested << association.foreign_key
+            @optional_includes << association.name
+          end
+
+          association.name
+        end
+
+        includes_for_smart_search = []
+        if @collection && @collection.search_fields
+          includes_for_smart_search = @collection.search_fields
+                                                 .select { |field| field.include? '.' }
+                                                 .map { |field| field.split('.').first.to_sym }
+
+          includes_has_many = SchemaUtils.many_associations(@resource)
+                                         .select { |association| SchemaUtils.model_included?(association.klass) }
+                                         .map(&:name)
+
+          includes_for_smart_search = includes_for_smart_search & includes_has_many
+        end
+
         @includes = (includes & @field_names_requested).concat(includes_for_smart_search)
       else
-        @includes = includes
+        @includes = associations_has_one.map(&:name)
       end
     end
 
@@ -226,7 +310,7 @@ module ForestLiana
 
     def compute_select_fields
       select = ['_forest_admin_eager_load']
-      @params[:fields][@collection_name].split(',').each do |path|
+      @field_names_requested.each do |path|
         association = get_one_association(path)
         if association
           while association.options[:through]

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "9.12.2"
+  VERSION = "9.14.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_liana
 version: !ruby/object:Gem::Version
-  version: 9.12.2
+  version: 9.14.0
 platform: ruby
 authors:
 - Sandro Munda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-15 00:00:00.000000000 Z
+date: 2025-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails