Fix #248 - Reload all accounts when fetching from cache

app/controllers/application_controller.rb

@@ -61,7 +61,7 @@ class ApplicationController < ActionController::Base
   def cache_collection(raw, klass)
     return raw unless klass.respond_to?(:with_includes)
 
-    raw                    = raw.select(:id, :updated_at).to_a if raw.is_a?(ActiveRecord::Relation)
+    raw                    = raw.cache_ids.to_a if raw.is_a?(ActiveRecord::Relation)
     uncached_ids           = []
     cached_keys_with_value = Rails.cache.read_multi(*raw.map(&:cache_key))
 
@@ -69,6 +69,8 @@ class ApplicationController < ActionController::Base
       uncached_ids << item.id unless cached_keys_with_value.key?(item.cache_key)
     end
 
+    klass.reload_stale_associations!(cached_keys_with_value.values) if klass.respond_to?(:reload_stale_associations!)
+
     unless uncached_ids.empty?
       uncached = klass.where(id: uncached_ids).with_includes.map { |item| [item.id, item] }.to_h
 

app/models/concerns/cacheable.rb

@@ -11,5 +11,6 @@ module Cacheable
 
   included do
     scope :with_includes, -> { includes(@cache_associated) }
+    scope :cache_ids, -> { select(:id, :updated_at) }
   end
 end

app/models/feed.rb

@@ -14,9 +14,9 @@ class Feed
     # If we're after most recent items and none are there, we need to precompute the feed
     if unhydrated.empty? && max_id == '+inf' && since_id == '-inf'
       RegenerationWorker.perform_async(@account.id, @type)
-      @statuses = Status.send("as_#{@type}_timeline", @account).paginate_by_max_id(limit, nil, nil)
+      @statuses = Status.send("as_#{@type}_timeline", @account).cache_ids.paginate_by_max_id(limit, nil, nil)
     else
-      status_map = Status.where(id: unhydrated).map { |s| [s.id, s] }.to_h
+      status_map = Status.where(id: unhydrated).cache_ids.map { |s| [s.id, s] }.to_h
       @statuses  = unhydrated.map { |id| status_map[id] }.compact
     end
 

app/models/notification.rb

@@ -5,6 +5,7 @@ class Notification < ApplicationRecord
   include Cacheable
 
   belongs_to :account
+  belongs_to :from_account, class_name: 'Account'
   belongs_to :activity, polymorphic: true
 
   belongs_to :mention,   foreign_type: 'Mention',   foreign_key: 'activity_id'
@@ -16,7 +17,7 @@ class Notification < ApplicationRecord
 
   STATUS_INCLUDES = [:account, :stream_entry, :media_attachments, :tags, mentions: :account, reblog: [:stream_entry, :account, :media_attachments, :tags, mentions: :account]].freeze
 
-  cache_associated status: STATUS_INCLUDES, mention: [status: STATUS_INCLUDES], favourite: [:account, status: STATUS_INCLUDES], follow: :account
+  cache_associated :from_account, status: STATUS_INCLUDES, mention: [status: STATUS_INCLUDES], favourite: [:account, status: STATUS_INCLUDES], follow: :account
 
   def activity
     send(activity_type.downcase)
@@ -31,15 +32,6 @@ class Notification < ApplicationRecord
     end
   end
 
-  def from_account
-    case type
-    when :mention
-      activity.status.account
-    when :follow, :favourite, :reblog
-      activity.account
-    end
-  end
-
   def target_status
     case type
     when :reblog
@@ -48,4 +40,15 @@ class Notification < ApplicationRecord
       activity.status
     end
   end
+
+  class << self
+    def reload_stale_associations!(cached_items)
+      account_ids = cached_items.map(&:from_account_id).uniq
+      accounts    = Account.where(id: account_ids).map { |a| [a.id, a] }.to_h
+
+      cached_items.each do |item|
+        item.from_account = accounts[item.from_account_id]
+      end
+    end
+  end
 end

app/models/status.rb

@@ -130,6 +130,22 @@ class Status < ApplicationRecord
       select('reblog_of_id').where(reblog_of_id: status_ids).where(account_id: account_id).map { |s| [s.reblog_of_id, true] }.to_h
     end
 
+    def reload_stale_associations!(cached_items)
+      account_ids = []
+
+      cached_items.each do |item|
+        account_ids << item.account_id
+        account_ids << item.reblog.account_id if item.reblog?
+      end
+
+      accounts = Account.where(id: account_ids.uniq).map { |a| [a.id, a] }.to_h
+
+      cached_items.each do |item|
+        item.account = accounts[item.account_id]
+        item.reblog.account = accounts[item.reblog.account_id] if item.reblog?
+      end
+    end
+
     private
 
     def filter_timeline(query, account)