fix: improve performance by only serializing requested fields

Author: DayTF

app/controllers/forest_liana/application_controller.rb

@@ -156,10 +156,12 @@ def fields_per_model(params_fields, model)
         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 @@ def fields_per_model(params_fields, model)
                 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

app/serializers/forest_liana/serializer_factory.rb

@@ -47,6 +47,81 @@ def self.get_serializer_name(active_record_class)
       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 @@ def relationship_related_link(attribute_name)
           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?

app/services/forest_liana/resources_getter.rb

@@ -74,55 +74,9 @@ def records
         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)
 

spec/requests/resources_spec.rb

@@ -124,18 +124,7 @@
           "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