thredded 0.14.4 → 0.15.1

data/lib/thredded/arel_compat.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+unless Rails::VERSION::MAJOR == 5 && Rails::VERSION::MINOR >= 2 || Rails::VERSION::MAJOR > 5
+  require 'thredded/rails_lt_5_2_arel_case_node.rb'
+end
+
+module Thredded
+  module ArelCompat
+    module_function
+
+    # @param [#connection] engine
+    # @param [Arel::Nodes::Node] a integer node
+    # @param [Arel::Nodes::Node] b integer node
+    # @return [Arel::Nodes::Node] a / b
+    def integer_division(engine, a, b)
+      if engine.connection.adapter_name =~ /mysql|mariadb/i
+        Arel::Nodes::InfixOperation.new('DIV', a, b)
+      else
+        Arel::Nodes::Division.new(a, b)
+      end
+    end
+
+    if Rails::VERSION::MAJOR == 5 && Rails::VERSION::MINOR >= 2 || Rails::VERSION::MAJOR > 5
+      # @param [ActiveRecord::Relation] relation
+      # @return [Arel::Nodes::Node]
+      def relation_to_arel(relation)
+        relation.arel
+      end
+    else
+      def relation_to_arel(relation)
+        Arel.sql("(#{relation.to_sql})")
+      end
+    end
+
+    if Rails::VERSION::MAJOR >= 5
+      # @param [Arel::Nodes::Node] table
+      # @return [Arel::SelectManager]
+      def new_arel_select_manager(table)
+        Arel::SelectManager.new(table)
+      end
+    else
+      def new_arel_select_manager(table)
+        Arel::SelectManager.new(ActiveRecord::Base, table)
+      end
+    end
+
+    if Rails::VERSION::MAJOR == 5 && Rails::VERSION::MINOR >= 2 || Rails::VERSION::MAJOR > 5
+      def true_value(_engine)
+        true
+      end
+    else
+      def true_value(engine)
+        engine.connection.adapter_name =~ /sqlite|mysql|mariadb/i ? 1 : true
+      end
+    end
+  end
+end

data/lib/thredded/base_migration.rb

@@ -2,6 +2,8 @@
 
 module Thredded
   class BaseMigration < (Thredded.rails_gte_51? ? ActiveRecord::Migration[5.1] : ActiveRecord::Migration)
+    protected
+
     def user_id_type
       Thredded.user_class.columns.find { |c| c.name == Thredded.user_class.primary_key }.sql_type
     end
@@ -10,5 +12,13 @@ module Thredded
       column_name = column_name.to_s
       columns(table).find { |c| c.name == column_name }.sql_type
     end
+
+    # @return [Integer, nil] the maximum number of codepoints that can be indexed for a primary key or index.
+    def max_key_length
+      return nil unless connection.adapter_name =~ /mysql|maria/i
+      # Conservatively assume that innodb_large_prefix is **disabled**.
+      # If it were enabled, the maximum key length would instead be 768 utf8mb4 characters.
+      191
+    end
   end
 end

data/lib/thredded/collection_to_strings_with_cache_renderer.rb

@@ -1,15 +1,26 @@
 # frozen_string_literal: true
 
 require 'action_view/renderer/abstract_renderer'
+
 module Thredded
   class CollectionToStringsWithCacheRenderer < ActionView::AbstractRenderer
+    class << self
+      # The default number of threads to use for rendering.
+      attr_accessor :render_threads
+    end
+
+    self.render_threads = 50
+
     # @param view_context
-    # @param collection [Array<T>]
-    # @param partial [String]
-    # @param expires_in [ActiveSupport::Duration]
+    # @param [Array<T>] collection
+    # @param [String] partial
+    # @param [ActiveSupport::Duration] expires_in
+    # @param [Integer] render_threads the number of threads to use for rendering. This is useful even on MRI ruby
+    #   for IO-bound operations.
+    # @param [Hash] locals
     # @return Array<[T, String]>
     def render_collection_to_strings_with_cache( # rubocop:disable Metrics/ParameterLists
-      view_context, collection:, partial:, expires_in:, locals: {}, **opts
+      view_context, collection:, partial:, expires_in:, render_threads: self.class.render_threads, locals: {}, **opts
     )
       template = @lookup_context.find_template(partial, [], true, locals, {})
       collection = collection.to_a
@@ -28,7 +39,9 @@ module Thredded
 
         collection_to_render = keyed_collection.reject { |key, _| cached_partials.key?(key) }.values
         rendered_partials = render_partials(
-          view_context, collection: collection_to_render, partial: partial, locals: locals, **opts
+          view_context,
+          collection: collection_to_render, render_threads: render_threads,
+          partial: partial, locals: locals, **opts
         ).each
 
         keyed_collection.map do |cache_key, item|
@@ -52,12 +65,25 @@ module Thredded
     end
 
     # @return [Array<String>]
-    def render_partials(view_context, collection:, **opts)
+    def render_partials(view_context, collection:, render_threads:, **opts)
       return [] if collection.empty?
-      partial_renderer = ActionView::PartialRenderer.new(@lookup_context)
-      collection.map do |item|
-        partial_renderer.render(view_context, opts.merge(object: item), nil)
+      num_threads = [render_threads, collection.size].min
+      if num_threads == 1
+        render_partials_serial(view_context, collection, opts)
+      else
+        collection.each_slice(collection.size / num_threads).map do |slice|
+          Thread.start { render_partials_serial(view_context.dup, slice, opts) }
+        end.flat_map(&:value)
       end
     end
+
+    # @param [Array<Object>] collection
+    # @param [Hash] opts
+    # @param view_context
+    # @return [Array<String>]
+    def render_partials_serial(view_context, collection, opts)
+      partial_renderer = ActionView::PartialRenderer.new(@lookup_context)
+      collection.map { |object| partial_renderer.render(view_context, opts.merge(object: object), nil) }
+    end
   end
 end

data/lib/thredded/content_formatter.rb

@@ -3,8 +3,30 @@
 module Thredded
   # Generates HTML from content source.
   class ContentFormatter
-    # Sanitization whitelist options.
-    mattr_accessor :whitelist
+    class << self
+      # Sanitization whitelist options.
+      attr_accessor :whitelist
+
+      # Filters that run before processing the markup.
+      # input: markup, output: markup.
+      attr_accessor :before_markup_filters
+
+      # Markup filters, such as BBCode, Markdown, Autolink, etc.
+      # input: markup, output: html.
+      attr_accessor :markup_filters
+
+      # Filters that run after processing the markup.
+      # input: html, output: html.
+      attr_accessor :after_markup_filters
+
+      # Filters that sanitize the resulting HTML.
+      # input: html, output: sanitized html.
+      attr_accessor :sanitization_filters
+
+      # Filters that run after sanitization
+      # input: sanitized html, output: html
+      attr_accessor :after_sanitization_filters
+    end
 
     self.whitelist = HTML::Pipeline::SanitizationFilter::WHITELIST.deep_merge(
       elements: HTML::Pipeline::SanitizationFilter::WHITELIST[:elements] + %w[abbr iframe span figure figcaption],
@@ -25,44 +47,31 @@ module Thredded
         'span'   => %w[class],
         'div'    => %w[class],
         :all     => HTML::Pipeline::SanitizationFilter::WHITELIST[:attributes][:all] +
-          %w[aria-label aria-labelledby aria-hidden],
+          %w[aria-expanded aria-label aria-labelledby aria-live aria-hidden aria-pressed role],
       }
     )
 
-    # Filters that run before processing the markup.
-    # input: markup, output: markup.
-    mattr_accessor :before_markup_filters
     self.before_markup_filters = [
+      Thredded::HtmlPipeline::SpoilerTagFilter::BeforeMarkup
     ]
 
-    # Markup filters, such as BBCode, Markdown, Autolink, etc.
-    # input: markup, output: html.
-    mattr_accessor :markup_filters
     self.markup_filters = [
       Thredded::HtmlPipeline::KramdownFilter,
     ]
 
-    # Filters that run after processing the markup.
-    # input: html, output: html.
-    mattr_accessor :after_markup_filters
     self.after_markup_filters = [
       # AutolinkFilter is required because Kramdown does not autolink by default.
       # https://github.com/gettalong/kramdown/issues/306
       Thredded::HtmlPipeline::AutolinkFilter,
       HTML::Pipeline::EmojiFilter,
       Thredded::HtmlPipeline::AtMentionFilter,
+      Thredded::HtmlPipeline::SpoilerTagFilter::AfterMarkup,
     ]
 
-    # Filters that sanitize the resulting HTML.
-    # input: html, output: sanitized html.
-    mattr_accessor :sanitization_filters
     self.sanitization_filters = [
       HTML::Pipeline::SanitizationFilter,
     ]
 
-    # Filters that run after sanitization
-    # input: sanitized html, output: html
-    mattr_accessor :after_sanitization_filters
     self.after_sanitization_filters = [
       Thredded::HtmlPipeline::OneboxFilter,
       Thredded::HtmlPipeline::WrapIframesFilter,

data/lib/thredded/database_seeder.rb

@@ -12,40 +12,128 @@ rescue NameError
 end
 # rubocop:enable HandleExceptions
 module Thredded
-  class DatabaseSeeder
+  class DatabaseSeeder # rubocop:disable Metrics/ClassLength
+    module LogTime
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def log_time
+        start = Time.now.to_f
+        result = yield
+        print_time_diff start
+        result
+      end
+
+      def print_time_diff(from, to = Time.now.to_f)
+        log " [#{format('%.2f', to - from)}s]\n"
+      end
+
+      module ClassMethods
+        def log_method_time(method_name)
+          prepend(Module.new do
+            define_method method_name do |*args, **kwargs|
+              log_time { super(*args, **kwargs) }
+            end
+          end)
+          method_name
+        end
+      end
+    end
+
+    include LogTime
+
     SKIP_CALLBACKS = [
-      [Thredded::Post, :commit, :after, :auto_follow_and_notify],
-      [Thredded::PrivatePost, :commit, :after, :notify_users],
+      [Thredded::Post, :commit, :after, :update_parent_last_user_and_time_from_last_post, on: %i[create destroy]],
+      [Thredded::Post, :commit, :after, :update_parent_last_user_and_time_from_last_post_if_moderation_state_changed,
+       on: :update],
+      [Thredded::Post, :commit, :after, :auto_follow_and_notify, on: %i[create update]],
+      [Thredded::PrivatePost, :commit, :after, :update_parent_last_user_and_timestamp, on: %i[create destroy]],
+      [Thredded::PrivatePost, :commit, :after, :notify_users, on: [:create]],
+    ].freeze
+    DISABLE_COUNTER_CACHE = [Thredded::Post, Thredded::PrivatePost].freeze
+    WRITEABLE_READONLY_ATTRIBUTES = [
+      [Thredded::Topic, 'posts_count'],
+      [Thredded::PrivateTopic, 'posts_count'],
     ].freeze
 
-    def self.run(users: 200, topics: 55, posts: (1..60))
-      STDERR.puts 'Seeding the database...'
+    # Applies global tweaks required to run seeder methods for the given block.
+    def self.with_seeder_tweaks
       # Disable callbacks to avoid creating notifications and performing unnecessary updates
-      SKIP_CALLBACKS.each { |(klass, *args)| klass.skip_callback(*args) }
-      s = new
-      Messageboard.transaction do
-        s.seed(users: users, topics: topics, posts: posts)
-        s.log 'Running after_commit callbacks'
+      DISABLE_COUNTER_CACHE.each do |klass|
+        klass.send(:alias_method, :original_each_counter_cached_associations, :each_counter_cached_associations)
+        klass.send(:define_method, :each_counter_cached_associations) {}
       end
+      SKIP_CALLBACKS.each { |(klass, *args)| delete_callbacks(klass, *args) }
+      WRITEABLE_READONLY_ATTRIBUTES.each { |(klass, attr)| klass.readonly_attributes.delete(attr) }
+      logger_was = ActiveRecord::Base.logger
+      ActiveRecord::Base.logger = nil
+      yield
     ensure
-      # Re-enable callbacks
-      SKIP_CALLBACKS.each { |(klass, *args)| klass.set_callback(*args) }
+      # Re-enable callbacks and counter cache
+      DISABLE_COUNTER_CACHE.each do |klass|
+        klass.send(:remove_method, :each_counter_cached_associations)
+        klass.send(:alias_method, :each_counter_cached_associations, :original_each_counter_cached_associations)
+        klass.send(:remove_method, :original_each_counter_cached_associations)
+      end
+      SKIP_CALLBACKS.each do |(klass, *args)|
+        args = args.dup
+        klass.send(:set_options_for_callbacks!, args)
+        klass.set_callback(*args)
+      end
+      WRITEABLE_READONLY_ATTRIBUTES.each { |(klass, attr)| klass.readonly_attributes << attr }
+      ActiveRecord::Base.logger = logger_was
+    end
+
+    def self.delete_callbacks(klass, name, *filter_list, &block)
+      type, filters, _options = klass.normalize_callback_params(filter_list, block)
+      klass.__update_callbacks(name) do |target, chain|
+        filters.each do |filter|
+          chain.delete(chain.find { |c| c.matches?(type, filter) })
+        end
+        target.send :set_callbacks, name, chain
+      end
+    end
+
+    def self.run(**kwargs)
+      new.run(**kwargs)
     end
 
-    def seed(users: 200, topics: 55, posts: (1..60))
-      users(count: users)
-      first_messageboard
-      topics(count: topics)
-      private_topics(count: topics)
-      posts(count: posts)
-      private_posts(count: posts)
-      create_additional_messageboards
-      follow_some_topics
-      read_some_topics
+    def run(users: 200, topics: 70, posts: (1..70))
+      log "Seeding the database...\n"
+      self.class.with_seeder_tweaks do
+        t_txn_0 = nil
+        Messageboard.transaction do
+          initialize_fake_post_contents(topics: topics, posts: posts)
+          users(count: users)
+          first_messageboard
+          topics(count: topics)
+          private_topics(count: topics)
+          posts(count: posts)
+          private_posts(count: posts)
+          create_additional_messageboards
+          follow_some_topics
+          read_some_topics(count: (topics / 4..topics / 3))
+          update_messageboards_data
+          t_txn_0 = Time.now.to_f
+          log 'Committing transaction and running after_commit callbacks'
+        end
+        print_time_diff t_txn_0
+      end
     end
 
     def log(message)
-      STDERR.puts "- #{message}"
+      STDERR.write "- #{message}"
+      STDERR.flush
+    end
+
+    log_method_time def initialize_fake_post_contents(topics:, posts:)
+      log 'Initializing fake post contents...'
+      @fake_post_contents = Array.new([topics * (posts.min + posts.max) / 2, 1000].min) { FakeContent.post_content }
+    end
+
+    def fake_post_contents
+      @fake_post_contents ? @fake_post_contents.sample : FakeContent.post_content
     end
 
     def first_user
@@ -56,6 +144,12 @@ module Thredded
       @users ||= Users.new(self).find_or_create(count: count)
     end
 
+    def user_details
+      @user_details ||= users.each_with_object({}) do |user, hash|
+        hash[user] = user.thredded_user_detail
+      end
+    end
+
     def first_messageboard
       @first_messageboard ||= FirstMessageboard.new(self).find_or_create
     end
@@ -68,10 +162,19 @@ module Thredded
          'Need help using the forum? Want to report a bug or make a suggestion? This is the place.', meta_group_id],
         ['Praise', 'Want to tell us how great we are? This is the place.', meta_group_id]
       ]
-      log "Creating #{additional_messageboards.length} additional messageboards..."
+      log "Creating #{additional_messageboards.length} additional messageboards...\n"
       additional_messageboards.each do |(name, description, group_id)|
         messageboard = Messageboard.create!(name: name, description: description, messageboard_group_id: group_id)
-        FactoryBot.create_list(:topic, 1 + rand(3), messageboard: messageboard, with_posts: 1)
+        topics = Topics.new(self).create(count: 1 + rand(3), messageboard: messageboard)
+        Posts.new(self).create(count: (1..2), topics: topics)
+      end
+    end
+
+    log_method_time def update_messageboards_data(**) # `**` for Ruby < 2.5, see https://bugs.ruby-lang.org/issues/10856
+      log 'Updating messageboards data...'
+      Messageboard.all.each do |messageboard|
+        messageboard.update_last_topic!
+        Thredded::Messageboard.reset_counters(messageboard.id, :posts)
       end
     end
 
@@ -91,10 +194,12 @@ module Thredded
       @private_posts ||= PrivatePosts.new(self).find_or_create(count: count)
     end
 
-    def follow_some_topics(count: (5..10), count_users: (1..5))
+    log_method_time def follow_some_topics(count: (5..10), count_users: (1..5))
       log 'Following some topics...'
       posts.each do |post|
-        Thredded::UserTopicFollow.create_unless_exists(post.user_id, post.postable_id, :posted) if post.user_id
+        next unless post.user_id
+        Thredded::UserTopicFollow.create_with(reason: :posted)
+          .find_or_create_by(user_id: post.user_id, topic_id: post.postable_id)
       end
       follow_some_topics_by_user(first_user, count: count)
       users.sample(count_users.min + rand(count_users.max - count_users.min + 2)).each do |user|
@@ -104,11 +209,11 @@ module Thredded
 
     def follow_some_topics_by_user(user, count: (1..10))
       topics.sample(count.min + rand(count.max - count.min + 2)).each do |topic|
-        Thredded::UserTopicFollow.create_unless_exists(user.id, topic.id)
+        Thredded::UserTopicFollow.create_with(reason: :manual).find_or_create_by(user_id: user.id, topic_id: topic.id)
       end
     end
 
-    def read_some_topics(count: (5..10), count_users: (1..5))
+    log_method_time def read_some_topics(count: (5..10), count_users: (1..5))
       log 'Reading some topics...'
       topics.each do |topic|
         read_topic(topic, topic.last_user_id) if topic.last_user_id
@@ -126,11 +231,18 @@ module Thredded
     end
 
     def read_topic(topic, user_id)
-      Thredded::UserTopicReadState.find_or_initialize_by(user_id: user_id, postable_id: topic.id)
-        .update!(read_at: topic.updated_at, page: 1)
+      read_state = Thredded::UserTopicReadState.find_or_initialize_by(user_id: user_id, postable_id: topic.id)
+      if rand(2).zero?
+        read_state.update!(read_at: topic.updated_at)
+      else
+        read_state.update!(read_at: topic.posts.order_newest_first.first(2).last.created_at)
+      end
     end
 
     class BaseSeedData
+      include LogTime
+
+      # @return [Thredded::DatabaseSeeder]
       attr_reader :seeder
 
       def initialize(seed_database = DatabaseSeeder.new)
@@ -149,6 +261,11 @@ module Thredded
         @stored = (find || create(*args))
       end
 
+      def range_of_dates_in_order(up_to: Time.zone.now, count: 1)
+        written = up_to
+        Array.new(count - 1) { written -= random_duration(10.minutes..6.hours) }.reverse + [up_to]
+      end
+
       protected
 
       def model_class
@@ -164,6 +281,10 @@ module Thredded
       def find
         fail 'Unimplemented'
       end
+
+      def random_duration(range)
+        (range.min.to_i + rand(range.max.to_i)).seconds
+      end
     end
 
     class FirstSeedData < BaseSeedData
@@ -183,7 +304,6 @@ module Thredded
       MODEL_CLASS = User
 
       def create
-        log 'Creating first user...'
         FactoryBot.create(:user, :approved, :admin, name: 'Joe', email: 'joe@example.com')
       end
     end
@@ -192,19 +312,19 @@ module Thredded
     class Users < CollectionSeedData
       MODEL_CLASS = User
 
-      def create(count: 1)
+      log_method_time def create(count: 1)
         log "Creating #{count} users..."
         approved_users_count = (count * 0.97).round
         [seeder.first_user] +
-          FactoryBot.create_list(:user, approved_users_count, :approved) +
-          FactoryBot.create_list(:user, count - approved_users_count)
+        FactoryBot.create_list(:user, approved_users_count, :approved, :with_user_details) +
+        FactoryBot.create_list(:user, count - approved_users_count, :with_user_details)
       end
     end
 
     class FirstMessageboard < FirstSeedData
       MODEL_CLASS = Messageboard
 
-      def create
+      log_method_time def create(**) # `**` for Ruby < 2.5, see https://bugs.ruby-lang.org/issues/10856
         log 'Creating a messageboard...'
         @first_messageboard = FactoryBot.create(
           :messageboard,
@@ -218,28 +338,39 @@ module Thredded
     class Topics < CollectionSeedData
       MODEL_CLASS = Topic
 
-      def create(count: 1, messageboard: seeder.first_messageboard)
+      log_method_time def create(count: 1, messageboard: seeder.first_messageboard)
         log "Creating #{count} topics in #{messageboard.name}..."
-        FactoryBot.create_list(
-          :topic, count,
-          messageboard: messageboard,
-          user: seeder.users.sample,
-          last_user: seeder.users.sample
-        )
+        Array.new(count) do
+          FactoryBot.build(
+            :topic,
+            messageboard: messageboard,
+            user: seeder.users.sample,
+            last_user: seeder.users.sample
+          ).tap do |topic|
+            topic.user_detail = seeder.user_details[topic.user]
+            topic.send :set_slug
+            topic.send :set_default_moderation_state
+            topic.save(validate: false)
+          end
+        end
       end
     end
 
     class PrivateTopics < CollectionSeedData
       MODEL_CLASS = PrivateTopic
 
-      def create(count: 1)
+      log_method_time def create(count: 1)
+        log "Creating #{count} private topics..."
         Array.new(count) do
-          FactoryBot.create(
+          FactoryBot.build(
             :private_topic,
             user: seeder.users[1..-1].sample,
             last_user: seeder.users.sample,
             users: [seeder.first_user, *seeder.users.sample(1 + rand(3))]
-          )
+          ).tap do |topic|
+            topic.send :set_slug
+            topic.save(validate: false)
+          end
         end
       end
     end
@@ -247,41 +378,64 @@ module Thredded
     class Posts < CollectionSeedData
       MODEL_CLASS = Post
 
-      def create(count: (1..1))
+      log_method_time def create(count: (1..1), topics: seeder.topics) # rubocop:disable Metrics/MethodLength
         log "Creating #{count} additional posts in each topic..."
-        seeder.topics.flat_map do |topic|
-          last_post_at = random_duration(0..72.hours).ago
+        topics.flat_map do |topic|
+          last_post_at = random_duration(0..256.hours).ago
           posts_count = (count.min + rand(count.max + 1))
           posts = range_of_dates_in_order(up_to: last_post_at, count: posts_count).map.with_index do |written_at, i|
             author = i.zero? ? topic.user : seeder.users.sample
-            FactoryBot.create(:post, postable: topic, messageboard: seeder.first_messageboard,
-                                     user: author, created_at: written_at, updated_at: written_at)
+            Post.new(
+              content: seeder.fake_post_contents,
+              messageboard_id: topic.messageboard_id,
+              postable: topic,
+              user: author,
+              user_detail: seeder.user_details[author],
+              created_at: written_at,
+              updated_at: written_at,
+            ).tap do |post|
+              post.send :set_default_moderation_state
+              post.save(validate: false)
+            end
           end
-          topic.update!(last_user_id: posts.last.user.id, updated_at: last_post_at, last_post_at: last_post_at)
+          topic.update_columns(
+            posts_count: posts_count,
+            last_user_id: posts.last.user.id,
+            updated_at: last_post_at,
+            last_post_at: last_post_at
+          )
           posts
         end
       end
-
-      def range_of_dates_in_order(up_to: Time.zone.now, count: 1)
-        written = up_to
-        Array.new(count - 1) { written -= random_duration(10.minutes..6.hours) }.reverse + [up_to]
-      end
-
-      def random_duration(range)
-        (range.min.to_i + rand(range.max.to_i)).seconds
-      end
     end
 
     class PrivatePosts < CollectionSeedData
       MODEL_CLASS = PrivatePost
 
-      def create(count: (1..1))
+      log_method_time def create(count: (1..1))
         log "Creating #{count} additional posts in each private topic..."
         seeder.private_topics.flat_map do |topic|
-          (count.min + rand(count.max + 1)).times do |i|
+          last_post_at = random_duration(0..256.hours).ago
+          posts_count = (count.min + rand(count.max + 1))
+          posts = range_of_dates_in_order(up_to: last_post_at, count: posts_count).map.with_index do |written_at, i|
             author = i.zero? ? topic.user : topic.users.sample
-            FactoryBot.create(:private_post, postable: topic, user: author)
+            PrivatePost.new(
+              postable: topic,
+              user: author,
+              created_at: written_at,
+              updated_at: written_at,
+              content: seeder.fake_post_contents,
+            ).tap do |post|
+              post.save(validate: false)
+            end
           end
+          topic.update_columns(
+            posts_count: posts_count,
+            last_user_id: posts.last.user.id,
+            updated_at: last_post_at,
+            last_post_at: last_post_at
+          )
+          posts
         end
       end
     end