[WIP] feat(reversibility): add component resource cache for filtering resource side records + add followers to bundle

Author: moustachu

app/services/decidim/content/csv_bundler.rb

@@ -117,10 +117,7 @@ def bundle
                               include_if: ->(parent) { parent&.manifest_name == "debates" },
                               serializer: Decidim::Content::DebateSerializer,
                               collection: lambda { |parent|
-                                Decidim::Debates::Debate
-                                .not_hidden
-                                .where(component: parent)
-                                .includes(:category)
+                                debates_for_component(parent).includes(:category)
                               }
                             },
                             {
@@ -156,9 +153,15 @@ def bundle
                             },
                             {
                               path: "endorsements",
-                              include_if: ->(parent) { endorsable_component?(parent&.manifest_name) && parent&.manifest_name == "proposals" },
+                              include_if: ->(parent) { endorsable_component?(parent&.manifest_name) && %w(proposals debates).include?(parent&.manifest_name) },
                               serializer: Decidim::Content::EndorsementSerializer,
                               collection: ->(parent) { endorsements_for_component(parent) }
+                            },
+                            {
+                              path: "followers",
+                              include_if: ->(parent) { followable_component?(parent&.manifest_name) && %w(proposals debates).include?(parent&.manifest_name) },
+                              serializer: Decidim::Content::FollowerSerializer,
+                              collection: ->(parent) { followers_for_component(parent) }
                             }
                           ]
                         }
@@ -312,13 +315,6 @@ def participatory_process_users(participatory_process)
         private_users = participatory_process.users.select(:decidim_user_id).reorder("decidim_user_id").to_a
         (users_with_roles + private_users).uniq(&:decidim_user_id).map { |o| o.attributes.compact.symbolize_keys.merge(role: o[:role] || "private_user") }
       end
-
-      def proposals_for_component(component)
-        Decidim::Proposals::Proposal
-          .published
-          .not_hidden
-          .where(component:)
-      end
     end
   end
 end

lib/concerns/decidim/content/component_tools.rb

@@ -7,6 +7,26 @@ module Content
     module ComponentTools
       extend ActiveSupport::Concern
       included do
+        def component_resource_cache
+          @component_resource_cache ||= Hash.new { |h, k| h[k] = h.dup.clear }
+        end
+
+        def component_resource_cache_set(component:, resource_class:, query:, force: false)
+          if force || component_resource_cache[component.id][resource_class.name].blank?
+            component_resource_cache[component.id][resource_class.name] = query
+          else
+            resource_class.none
+          end
+        end
+
+        def component_resource_cache_get(component:, resource_class:)
+          component_resource_cache[component.id][resource_class.name]
+        end
+
+        def component_resource_cache_exists?(component:, resource_class:)
+          component_resource_cache[component.id][resource_class.name].present?
+        end
+
         def component_resource_manifests(manifest_name)
           return [] if manifest_name.blank?
 
@@ -60,14 +80,21 @@ def comments_for_resource(resource_class, component)
               gateway_resources = gateway_reflection.try(:options)&.[](:class_name)&.constantize&.where(component:)
               root_commentable = gateway_resources.present? ? resource_class.where(through => gateway_resources) : resource_class.none
             end
+
+            if component_resource_cache_exists?(component:, resource_class:)
+              cached_ids = component_resource_cache_get(component:, resource_class:).pluck(:id)
+              root_commentable = root_commentable.where(id: cached_ids)
+            end
+
             if root_commentable.present?
               return Decidim::Comments::Comment
                      .not_deleted
                      .not_hidden
                      .where(root_commentable:)
             end
           end
-          Rails.logger.warn "Decidim::Content::ComponentTools.comments_for_resource (concerns) : Unable to fetch comments for #{resource_class} with component association."
+          Rails.logger.warn "Decidim::Content::ComponentTools.comments_for_resource (concerns) : No comments found for #{resource_class} with component association."
+          Rails.logger.warn "-- cached query was involved with #{cached_ids.size} records" if component_resource_cache_exists?(component:, resource_class:)
           Decidim::Comments::Comment.none
         end
         # rubocop:enable Metrics/CyclomaticComplexity
@@ -81,11 +108,56 @@ def endorsements_for_component(component)
 
         def endorsements_for_resource(resource_class, component)
           endorsable_resources = resource_class.where(component:)
+          if component_resource_cache_exists?(component:, resource_class:)
+            cached_ids = component_resource_cache_get(component:, resource_class:).pluck(:id)
+            endorsable_resources = endorsable_resources.where(id: cached_ids)
+          end
           return Decidim::Endorsement.where(resource: endorsable_resources) if endorsable_resources.present?
 
-          Rails.logger.warn "Decidim::Content::ComponentTools.endorsements_for_resource (concerns) : Unable to fetch endorsements for #{resource_class} with component association."
+          Rails.logger.warn "Decidim::Content::ComponentTools.endorsements_for_resource (concerns) : No endorsements found for #{resource_class} with component association."
+          Rails.logger.warn "-- cached query was involved with #{cached_ids.size} records" if component_resource_cache_exists?(component:, resource_class:)
           Decidim::Endorsement.none
         end
+
+        def followers_for_component(component)
+          component_resource_manifests_including_trait(component&.manifest_name, Decidim::Followable).each.with_object([]) do |manifest, results|
+            results.concat(followers_for_resource(manifest.model_class_name.constantize, component)) if manifest.model_class_name.present?
+          end
+        end
+
+        def followers_for_resource(resource_class, component)
+          followable_resources = resource_class.where(component:)
+          if component_resource_cache_exists?(component:, resource_class:)
+            cached_ids = component_resource_cache_get(component:, resource_class:).pluck(:id)
+            followable_resources = followable_resources.where(id: cached_ids)
+          end
+          return Decidim::Follow.where(followable: followable_resources) if followable_resources.present?
+
+          Rails.logger.warn "Decidim::Content::ComponentTools.followers_for_resource (concerns) : No followers found for #{resource_class} with component association."
+          Rails.logger.warn "-- cached query was involved with #{cached_ids.size} records" if component_resource_cache_exists?(component:, resource_class:)
+          Decidim::Follow.none
+        end
+
+        def proposals_for_component(component)
+          component_resource_cache_set(
+            component:,
+            resource_class: Decidim::Proposals::Proposal,
+            query: Decidim::Proposals::Proposal
+                    .published
+                    .not_hidden
+                    .where(component:)
+          )
+        end
+
+        def debates_for_component(component)
+          component_resource_cache_set(
+            component:,
+            resource_class: Decidim::Debates::Debate,
+            query: Decidim::Debates::Debate
+                    .not_hidden
+                    .where(component:)
+          )
+        end
       end
     end
   end

lib/concerns/decidim/content/uid_tools.rb

@@ -19,9 +19,14 @@ def locate_resource_by_uid(uid)
         end
 
         def polymorphic_uid(resource, key)
-          return unless key.present? && resource.respond_to?(key.to_sym)
+          return if key.blank?
 
-          uid(resource.try("#{key}_type".to_sym)&.safe_constantize&.new(id: resource.try("#{key}_id".to_sym)))
+          type_attribute = "#{key}_type".to_sym
+          id_attribute = "#{key}_id".to_sym
+          return unless resource.respond_to?(type_attribute) && resource.respond_to?(id_attribute)
+
+          # Rails.logger.debug { "polymorphic_uid: resource=#{resource.class.name} key=#{key} type=#{resource.try(type_attribute)} id=#{resource.try(id_attribute)}" }
+          uid(resource.try(type_attribute)&.safe_constantize&.new(id: resource.try(id_attribute)&.to_i))
         end
       end
     end