AI: address review on PR #461

backend/app/controllers/posts_controller.rb

@@ -37,6 +37,8 @@ class PostsController < ApplicationController
 
     offset = (page - 1) * limit
 
+    needs_history_join = order[0] == 'updated_at' || updated_between.any?(&:present?)
+
     q =
         filtered_posts(locale)
         .preload(:external_tags, :uploaded_user, :parents, :children,
@@ -54,9 +56,25 @@ class PostsController < ApplicationController
     end
     q = q.where('posts.created_at >= ?', created_between[0]) if created_between[0]
     q = q.where('posts.created_at <= ?', created_between[1]) if created_between[1]
-    q = q.where('posts.updated_at >= ?', updated_between[0]) if updated_between[0]
-    q = q.where('posts.updated_at <= ?', updated_between[1]) if updated_between[1]
     count_scope = q
+    if needs_history_join
+      history_times = HistoryAccess.visible(PostVersion.all)
+          .select('post_id, MAX(created_at) AS latest_at').group(:post_id)
+      q = q.joins("LEFT JOIN (#{ history_times.to_sql }) history_times " +
+                  'ON history_times.post_id = posts.id')
+      updated_at_all_sql = 'GREATEST(posts.updated_at, ' +
+          'COALESCE(history_times.latest_at, posts.updated_at))'
+    end
+    if updated_between[0]
+      q = q.where("#{ updated_at_all_sql } >= ?", updated_between[0])
+    end
+    if updated_between[1]
+      q = q.where("#{ updated_at_all_sql } <= ?", updated_between[1])
+    end
+    count_scope = q if updated_between.any?(&:present?)
+    if needs_history_join
+      q = q.select('posts.*', "#{ updated_at_all_sql } AS updated_at")
+    end
 
     sort_sql =
         case order[0]
@@ -64,6 +82,8 @@ class PostsController < ApplicationController
           'COALESCE(posts.original_created_before - INTERVAL 1 MINUTE,' +
           'posts.original_created_from,' +
           'posts.created_at) '
+        when 'updated_at'
+          updated_at_all_sql
         else
           "posts.#{ order[0] }"
         end
@@ -71,11 +91,20 @@ class PostsController < ApplicationController
              .limit(limit)
              .offset(offset)
              .to_a
+    latest_version_times =
+        if needs_history_join
+          { }
+        else
+          HistoryAccess.visible(PostVersion.where(post_id: posts.map(&:id)))
+              .group(:post_id).maximum(:created_at)
+        end
 
     count_scope = count_scope.except(:select, :order)
 
     render json: { posts: posts.map { |post|
-      PostRepr.base(post, language_code: locale.language_code).tap do |json|
+      updated_at = [post.updated_at, latest_version_times[post.id]].compact.max
+      PostRepr.base(post, language_code: locale.language_code)
+          .merge('updated_at' => updated_at).tap do |json|
         json['thumbnail'] =
             if post.thumbnail.attached?
               rails_storage_proxy_url(post.thumbnail, only_path: false)

backend/app/controllers/tag_descriptions_controller.rb

@@ -49,6 +49,7 @@ class TagDescriptionsController < ApplicationController
   private
 
   def representation description
+    HistoryAccess.require_current!(description, TagDescriptionVersion)
     description.as_json(only: [
         :tag_id,
         :language_code,

backend/app/controllers/tag_groups_controller.rb

@@ -1,7 +1,7 @@
 class TagGroupsController < ApplicationController
   def index
     locale = resolve_locale!
-    groups = TagGroup.includes(:created_by_user, :updated_by_user).order(:id)
+    groups = HistoryAccess.current(TagGroup.all, TagGroupVersion).includes(:created_by_user, :updated_by_user).order(:id)
     render json: TagGroupRepr.many(locale, groups.to_a)
   end
 

backend/app/controllers/wiki_pages_controller.rb

@@ -8,11 +8,12 @@ class WikiPagesController < ApplicationController
 
     title = params[:title].to_s.strip
     descriptions =
-        TagDescription.where(language_code: locale.language_code)
+        HistoryAccess.current(TagDescription.all, TagDescriptionVersion)
+        .where(language_code: locale.language_code)
         .includes(tag: :tag_names)
 
     descriptions = descriptions.order(updated_at: :desc, id: :asc)
-    tag_groups = TagGroup.order(updated_at: :desc, id: :asc)
+    tag_groups = HistoryAccess.current(TagGroup.all, TagGroupVersion).order(updated_at: :desc, id: :asc)
     if title.present?
       pattern = "%#{ ApplicationRecord.sanitize_sql_like(title) }%"
       descriptions =
@@ -40,13 +41,13 @@ class WikiPagesController < ApplicationController
     return head :not_found unless language.is_a?(String)
     return head :not_found unless Language.exists?(code: language)
 
-    names = TagDescription.joins(tag: :tag_names)
+    names = HistoryAccess.current(TagDescription.all, TagDescriptionVersion).joins(tag: :tag_names)
         .where(language_code: locale.language_code, tag_names: { language_code: language })
         .pluck('tag_descriptions.tag_id', 'tag_descriptions.id', 'tag_names.name')
     candidates = names.map do |tag_id, description_id, name|
       WikiPageRepr.autolink_tag(locale, tag_id:, description_id:, name:, language:)
     end
-    candidates.concat(TagGroup.order(:id).pluck(:id, :name).map do |id, name|
+    candidates.concat(HistoryAccess.current(TagGroup.all, TagGroupVersion).order(:id).pluck(:id, :name).map do |id, name|
       WikiPageRepr.autolink_group(locale, id:, name:, language:)
     end)
     render json: candidates
@@ -410,7 +411,7 @@ class WikiPagesController < ApplicationController
   end
 
   def tag_description_by_title locale, title
-    TagDescription.joins(tag: :tag_names)
+    HistoryAccess.current(TagDescription.all, TagDescriptionVersion).joins(tag: :tag_names)
         .find_by(language_code: locale.language_code,
                  tag_names: { language_code: locale.language_code, name: title })
   end

backend/app/models/history_access.rb

@@ -147,6 +147,29 @@ class HistoryAccess < ActiveSupport::CurrentAttributes
     scope.where(Arel.sql(sql(scope.klass, row)))
   end
 
+  def self.current(scope, version_model)
+    return scope if admin?
+
+    table = scope.klass.table_name
+    keys = KEYS.fetch(version_model.table_name)
+    matches = keys.map do |key|
+      column = scope.klass.column_names.include?(key) ? key : 'id'
+      "current_snapshot.#{ key } = #{ table }.#{ column }"
+    end.join(' AND ')
+    boundary = "#{ matches } AND current_snapshot.version_no >= #{ table }.version_no " +
+        "AND current_snapshot.event_type = 'discard'"
+    scope = scope.where(Arel.sql("NOT EXISTS (SELECT 1 FROM #{ version_model.table_name } " +
+        "current_snapshot WHERE #{ boundary })"))
+    condition = "#{ matches } AND current_snapshot.version_no = #{ table }.version_no"
+    scope.where(Arel.sql("NOT EXISTS (SELECT 1 FROM #{ version_model.table_name } " +
+        "current_snapshot WHERE #{ condition } AND NOT (#{ sql(version_model, 'current_snapshot') }))"))
+  end
+
+  def self.require_current!(record, version_model)
+    return if admin?
+    raise Forbidden unless current(record.class.where(id: record.id), version_model).exists?
+  end
+
   def self.blob_visible?(blob, seen = [])
     return true if admin?
     return false if seen.include?(blob.id)

backend/app/representations/tag_group_repr.rb

@@ -44,6 +44,7 @@ module TagGroupRepr
   end
 
   def one locale, group
+    HistoryAccess.require_current!(group, TagGroupVersion)
     many(locale, [group]).first
   end
 

backend/app/representations/wiki_page_repr.rb

@@ -5,6 +5,7 @@ module WikiPageRepr
   module_function
 
   def tag_description locale, description
+    HistoryAccess.require_current!(description, TagDescriptionVersion)
     tag = description.tag
 
     { 'id' => description.id,

backend/app/services/post_tag_search.rb

@@ -3,8 +3,8 @@ class PostTagSearch
   def self.literals(locale, raw)
     tokens = raw.split.reject { _1.downcase == 'type:or' }
     names = tokens.map { _1.sub(/\Anot:/i, '') }
-    registered = TagName.where(language_code: locale.language_code, name: names)
-        .pluck(:name, :tag_id).to_h
+    registered = matching_names(TagName.where(language_code: locale.language_code),
+        names, 'tag_names.name', :tag_id).to_h
     primary = TagName.where(language_code: locale.language_code,
         tag_id: registered.values, primary_flg: true).pluck(:tag_id, :name).to_h
     tokens.zip(names).map do |token, name|
@@ -19,12 +19,25 @@ class PostTagSearch
 
   def self.references_for(locale, literals)
     names = literals.map { _1[:name] }.uniq
-    internal = TagName.where(language_code: locale.language_code, name: names)
-        .pluck(:name, :tag_id).group_by(&:first)
-    external = names.empty? ? {} : ExternalTag.where(
-        "CONCAT(platform, ':', name) IN (?)", names)
-        .pluck(Arel.sql("CONCAT(platform, ':', name)"), :id).group_by(&:first)
+    internal = matching_names(TagName.where(language_code: locale.language_code),
+        names, 'tag_names.name', :tag_id).group_by(&:first)
+    external = matching_names(ExternalTag.all, names,
+        "CONCAT(external_tags.platform, ':', external_tags.name)", :id).group_by(&:first)
     names.to_h { |name| [name, [internal.fetch(name, []).map(&:last).uniq,
                               external.fetch(name, []).map(&:last).uniq]] }
   end
+
+  def self.matching_names(scope, names, expression, identifier)
+    return [] if names.empty?
+
+    queries = names.uniq.map do |name|
+      scope.klass.sanitize_sql_array(['SELECT ? AS name', name])
+    end
+    # Return the input spelling so Ruby does not recheck database equivalence.
+    scope.joins(<<~SQL).pluck(Arel.sql('search_names.name'), identifier)
+      INNER JOIN (#{ queries.join(' UNION ALL ') }) AS search_names
+        ON #{ expression } = search_names.name COLLATE utf8mb4_0900_ai_ci
+    SQL
+  end
+  private_class_method :matching_names
 end