feat(platforms): optimize platform memberships loading to prevent N+1 queries

feat(image_helper): enhance profile image handling with optimized URL method

feat(person): add non-blocking profile image variant and URL methods

test(image_helper): add specs for profile_image_tag method

test(performance): add performance tests for profile image loading

Author: rsmithlal

app/controllers/better_together/platforms_controller.rb

@@ -17,6 +17,9 @@ def index
     # GET /platforms/1
     def show
       authorize @platform
+      # Preload memberships with policy scope applied to prevent N+1 queries in view
+      # Include comprehensive associations for members and roles to eliminate N+1 queries
+      @platform_memberships = policy_scope(@platform.memberships_with_associations)
     end
 
     # GET /platforms/new
@@ -124,25 +127,45 @@ def resource_class
     end
 
     def resource_collection
-      # Comprehensive eager loading to prevent N+1 queries for platform memberships
-      # This loads all necessary associations including:
-      # - Mobility translations (string & text)
-      # - Active Storage attachments with blobs and variants
-      # - Platform memberships with member/role associations
-      # Note: Platform invitations are now loaded separately via lazy Turbo frames
-      resource_class.with_translations.includes(
-        # Cover and profile image attachments with blobs and variants
+      # Comprehensive eager loading to prevent N+1 queries across all platform associations
+      resource_class.includes(
+        # Platform's own translations and attachments
+        :string_translations,
+        :text_translations,
         cover_image_attachment: { blob: :variant_records },
         profile_image_attachment: { blob: :variant_records },
-        # Person platform memberships with comprehensive associations
-        person_platform_memberships: [
-          { member: [
-            :string_translations,
-            { profile_image_attachment: { blob: :variant_records } }
-          ] },
-          { role: %i[
+
+        # Community association with its own attachments
+        community: [
+          :string_translations,
+          :text_translations,
+          { profile_image_attachment: { blob: :variant_records } },
+          { cover_image_attachment: { blob: :variant_records } }
+        ],
+
+        # Content blocks
+        platform_blocks: {
+          block: %i[
             string_translations
-          ] }
+            text_translations
+          ]
+        },
+
+        # Person platform memberships with all necessary nested associations
+        person_platform_memberships: [
+          {
+            member: [
+              :string_translations,
+              :text_translations,
+              { profile_image_attachment: { blob: :variant_records } }
+            ]
+          },
+          {
+            role: %i[
+              string_translations
+              text_translations
+            ]
+          }
         ]
       )
     end

app/helpers/better_together/image_helper.rb

@@ -119,13 +119,17 @@ def profile_image_tag(entity, options = {}) # rubocop:todo Metrics/MethodLength,
 
       # Determine if entity has a profile image
       if entity.respond_to?(:profile_image) && entity.profile_image.attached?
-        attachment = if entity.respond_to?(:optimized_profile_image)
-                       entity.optimized_profile_image
-                     else
-                       entity.profile_image_variant(image_size)
-                     end
-
-        image_tag(rails_storage_proxy_url(attachment), **image_tag_attributes)
+        # Use optimized URL method that doesn't block on .processed
+        image_url = if entity.respond_to?(:profile_image_url)
+                      entity.profile_image_url(size: image_size)
+                    elsif entity.respond_to?(:optimized_profile_image)
+                      rails_storage_proxy_url(entity.optimized_profile_image)
+                    else
+                      # Fallback to variant without calling .processed
+                      rails_storage_proxy_url(entity.profile_image_variant(image_size))
+                    end
+
+        image_tag(image_url, **image_tag_attributes) if image_url
       else
         # Use a default image based on the entity type
         default_image = default_profile_image(entity, image_format)

app/models/better_together/person.rb

@@ -112,9 +112,24 @@ def email
     has_one_attached :profile_image
     has_one_attached :cover_image
 
-    # Resize the profile image before rendering
+    # Resize the profile image before rendering (non-blocking version)
     def profile_image_variant(size)
-      profile_image.variant(resize_to_fill: [size, size]).processed
+      return profile_image.variant(resize_to_fill: [size, size]) unless Rails.env.production?
+
+      # In production, avoid blocking .processed calls
+      profile_image.variant(resize_to_fill: [size, size])
+    end
+
+    # Get optimized profile image variant without blocking rendering
+    def profile_image_url(size: 300)
+      return nil unless profile_image.attached?
+
+      variant = profile_image.variant(resize_to_fill: [size, size])
+
+      # For better performance, use Rails URL helpers for variant
+      Rails.application.routes.url_helpers.url_for(variant)
+    rescue ActiveStorage::FileNotFoundError
+      nil
     end
 
     # Resize the cover image to specific dimensions

app/models/better_together/platform.rb

@@ -80,6 +80,26 @@ def primary_community_extra_attrs
       { host:, protected: }
     end
 
+    # Efficiently load platform memberships with all necessary associations
+    # to prevent N+1 queries in views
+    def memberships_with_associations
+      person_platform_memberships.includes(
+        {
+          member: [
+            :string_translations,
+            :text_translations,
+            { profile_image_attachment: { blob: { variant_records: [], preview_image_attachment: { blob: [] } } } }
+          ]
+        },
+        {
+          role: %i[
+            string_translations
+            text_translations
+          ]
+        }
+      )
+    end
+
     def to_s
       name
     end

app/views/better_together/platforms/show.html.erb

@@ -89,7 +89,7 @@
 
         <!-- Platform Members Section -->
         <section id="members" class="row row-cols-1 row-cols-md-2 row-cols-lg-3 row-cols-xl-4 collapse" aria-labelledby="members-tab" aria-expanded="false" data-bs-parent="#platformTabs">
-          <%= render partial: 'better_together/person_platform_memberships/person_platform_membership_member', collection: policy_scope(@platform.person_platform_memberships), as: :person_platform_membership %>
+          <%= render partial: 'better_together/person_platform_memberships/person_platform_membership_member', collection: @platform_memberships, as: :person_platform_membership %>
         </section>
 
         <% if policy(BetterTogether::PlatformInvitation).index? %>

spec/helpers/better_together/image_helper_spec.rb

@@ -0,0 +1,44 @@
+require 'rails_helper'
+
+RSpec.describe BetterTogether::ImageHelper, type: :helper do
+  include BetterTogether::ImageHelper
+
+  describe '#profile_image_tag' do
+    let(:person) { create(:better_together_person) }
+
+    context 'when person has no profile image' do
+      it 'returns a default image tag' do
+        result = profile_image_tag(person)
+        expect(result).to include('class="profile-image rounded-circle')
+        expect(result).to include('alt="Profile Image"')
+      end
+    end
+
+    context 'when person has profile_image_url method' do
+      before do
+        allow(person).to receive(:respond_to?).and_return(false)
+        allow(person).to receive(:respond_to?).with(:profile_image).and_return(true)
+        allow(person).to receive(:respond_to?).with(:profile_image, anything).and_return(true)
+        allow(person).to receive(:respond_to?).with(:profile_image_url).and_return(true)
+        allow(person).to receive(:respond_to?).with(:profile_image_url, anything).and_return(true)
+        allow(person).to receive(:profile_image_url).and_return('http://example.com/optimized.jpg')
+
+        # Mock profile_image.attached? to return true
+        profile_image_double = double('profile_image', attached?: true)
+        allow(person).to receive(:profile_image).and_return(profile_image_double)
+      end
+
+      it 'uses the optimized profile_image_url method' do
+        expect(person).to receive(:profile_image_url).with(size: 300)
+        result = profile_image_tag(person)
+        expect(result).to include('src="http://example.com/optimized.jpg"')
+        expect(result).to include('class="profile-image rounded-circle')
+      end
+
+      it 'respects custom size parameter' do
+        expect(person).to receive(:profile_image_url).with(size: 150)
+        profile_image_tag(person, size: 150)
+      end
+    end
+  end
+end

spec/performance/profile_image_performance_spec.rb

@@ -0,0 +1,71 @@
+require 'rails_helper'
+
+RSpec.describe 'Profile Image Performance', type: :request do
+  include ActiveSupport::Testing::TimeHelpers
+
+  before do
+    configure_host_platform
+  end
+
+  context 'with multiple platform members' do
+    let!(:platform) { create(:better_together_platform) }
+    let!(:people) { create_list(:better_together_person, 3) } # Reduce to 3 for faster test
+    let!(:role) { create(:better_together_role, :platform_role) } # Create platform role
+    let!(:memberships) do
+      people.map do |person|
+        create(:better_together_person_platform_membership,
+               joinable: platform,
+               member: person,
+               role: role) # Reuse the same platform role
+      end
+    end
+
+    it 'loads platform show page efficiently with profile images' do
+      # Measure execution time
+      start_time = Time.current
+
+      # Make request to platform show page
+      get better_together.platform_path(platform, locale: I18n.default_locale)
+
+      end_time = Time.current
+      execution_time = end_time - start_time
+
+      # Verify response is successful
+      expect(response).to have_http_status(:success)
+
+      # Log performance metrics (this will help track improvements)
+      Rails.logger.info "Platform show page with #{people.count} members loaded in #{execution_time} seconds"
+
+      # Performance expectation - should load in under 5 seconds
+      expect(execution_time).to be < 5.seconds
+
+      # Verify content includes member count (proving the associations loaded)
+      expect(response.body).to include('membership-column')
+
+      # Count the membership cards rendered
+      membership_count = response.body.scan('membership-column').length
+      expect(membership_count).to eq(people.count)
+    end
+  end
+
+  context 'profile_image_url method performance' do
+    let(:person) { create(:better_together_person) }
+
+    it 'calls profile_image_url without errors when no image is attached' do
+      start_time = Time.current
+
+      # Call our optimized method (should return nil gracefully)
+      result = person.profile_image_url(size: 150)
+
+      end_time = Time.current
+      execution_time = end_time - start_time
+
+      expect(result).to be_nil
+
+      # Should be reasonably fast (under 2 seconds for no image)
+      expect(execution_time).to be < 2.seconds
+
+      Rails.logger.info "profile_image_url method executed in #{execution_time} seconds"
+    end
+  end
+end