Merge remote-tracking branch 'parent/main' into kb_migration

app/services/batched_remove_status_service.rb

@@ -35,7 +35,10 @@ class BatchedRemoveStatusService < BaseService
 
     # Since we skipped all callbacks, we also need to manually
     # deindex the statuses
-    Chewy.strategy.current.update(StatusesIndex, statuses_and_reblogs) if Chewy.enabled?
+    if Chewy.enabled?
+      Chewy.strategy.current.update(StatusesIndex, statuses_and_reblogs)
+      Chewy.strategy.current.update(PublicStatusesIndex, statuses_and_reblogs)
+    end
 
     return if options[:skip_side_effects]
 

app/services/search_service.rb

@@ -41,41 +41,16 @@ class SearchService < BaseService
   end
 
   def perform_statuses_search!
-    privacy_definition = parsed_query.apply(StatusesIndex.filter(terms: { searchability: %w(public private direct) }).filter(term: { searchable_by: @account.id }))
-
-    # 'direct' searchability posts are NOT in here because it's already added at previous line.
-    case @searchability
-    when 'public'
-      privacy_definition = privacy_definition.or(StatusesIndex.filter(term: { searchability: 'public' }))
-      privacy_definition = privacy_definition.or(StatusesIndex.filter(term: { searchability: 'private' }).filter(terms: { account_id: following_account_ids })) unless following_account_ids.empty?
-      privacy_definition = privacy_definition.or(StatusesIndex.filter(term: { searchability: 'limited' }).filter(term: { account_id: @account.id }))
-    when 'private', 'direct'
-      privacy_definition = privacy_definition.or(StatusesIndex.filter(terms: { searchability: %w(public private) }).filter(terms: { account_id: following_account_ids })) unless following_account_ids.empty?
-      privacy_definition = privacy_definition.or(StatusesIndex.filter(term: { searchability: 'limited' }).filter(term: { account_id: @account.id }))
-    when 'limited'
-      privacy_definition = privacy_definition.or(StatusesIndex.filter(term: { searchability: 'limited' }).filter(term: { account_id: @account.id }))
-    end
-
-    definition = parsed_query.apply(StatusesIndex).order(id: :desc)
-    definition = definition.filter(term: { account_id: @options[:account_id] }) if @options[:account_id].present?
-
-    definition = definition.and(privacy_definition)
-
-    if @options[:min_id].present? || @options[:max_id].present?
-      range      = {}
-      range[:gt] = @options[:min_id].to_i if @options[:min_id].present?
-      range[:lt] = @options[:max_id].to_i if @options[:max_id].present?
-      definition = definition.filter(range: { id: range })
-    end
-
-    results             = definition.limit(@limit).offset(@offset).objects.compact
-    account_ids         = results.map(&:account_id)
-    account_domains     = results.map(&:account_domain)
-    account_relations   = @account.relations_map(account_ids, account_domains) # variable old name: preloaded_relations
-
-    results.reject { |status| StatusFilter.new(status, @account, account_relations).filtered? }
-  rescue Faraday::ConnectionFailed, Parslet::ParseFailed
-    []
+    StatusesSearchService.new.call(
+      @query,
+      @account,
+      limit: @limit,
+      offset: @offset,
+      account_id: @options[:account_id],
+      min_id: @options[:min_id],
+      max_id: @options[:max_id],
+      searchability: @searchability
+    )
   end
 
   def perform_hashtags_search!
@@ -132,17 +107,4 @@ class SearchService < BaseService
   def statuses_search?
     @options[:type].blank? || @options[:type] == 'statuses'
   end
-
-  def parsed_query
-    SearchQueryTransformer.new.apply(SearchQueryParser.new.parse(@query))
-  end
-
-  def following_account_ids
-    return @following_account_ids if defined?(@following_account_ids)
-
-    account_exists_sql     = Account.where('accounts.id = follows.target_account_id').where(searchability: %w(public private)).reorder(nil).select(1).to_sql
-    status_exists_sql      = Status.where('statuses.account_id = follows.target_account_id').where(reblog_of_id: nil).where(searchability: %w(public private)).reorder(nil).select(1).to_sql
-    following_accounts     = Follow.where(account_id: @account.id).merge(Account.where("EXISTS (#{account_exists_sql})").or(Account.where("EXISTS (#{status_exists_sql})")))
-    @following_account_ids = following_accounts.pluck(:target_account_id)
-  end
 end

app/services/statuses_search_service.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+class StatusesSearchService < BaseService
+  def call(query, account = nil, options = {})
+    @query   = query&.strip
+    @account = account
+    @options = options
+    @limit   = options[:limit].to_i
+    @offset  = options[:offset].to_i
+    @searchability = options[:searchability]&.to_sym
+
+    status_search_results
+  end
+
+  private
+
+  def status_search_results
+    definition_should = [
+      publicly_searchable,
+      non_publicly_searchable,
+      searchability_limited,
+    ]
+    definition_should << searchability_public if %i(public).include?(@searchability)
+    definition_should << searchability_private if %i(public private).include?(@searchability)
+
+    definition = parsed_query.apply(
+      StatusesIndex.filter(
+        bool: {
+          should: definition_should,
+          minimum_should_match: 1,
+        }
+      )
+    )
+
+    # This is the best way to submit identical queries to multi-indexes though chewy
+    definition.instance_variable_get(:@parameters)[:indices].value[:indices] << PublicStatusesIndex
+
+    results             = definition.collapse(field: :id).order(_id: { order: :desc }).limit(@limit).offset(@offset).objects.compact
+    account_ids         = results.map(&:account_id)
+    account_domains     = results.map(&:account_domain)
+    preloaded_relations = @account.relations_map(account_ids, account_domains)
+
+    results.reject { |status| StatusFilter.new(status, @account, preloaded_relations).filtered? }
+  rescue Faraday::ConnectionFailed, Parslet::ParseFailed
+    []
+  end
+
+  def publicly_searchable
+    {
+      bool: {
+        must_not: {
+          exists: {
+            field: 'searchable_by',
+          },
+        },
+      },
+    }
+  end
+
+  def non_publicly_searchable
+    {
+      bool: {
+        must: [
+          {
+            exists: {
+              field: 'searchable_by',
+            },
+          },
+          {
+            exists: {
+              field: 'searchability',
+            },
+          },
+          {
+            term: { searchable_by: @account.id },
+          },
+        ],
+        must_not: [
+          {
+            term: { searchability: 'limited' },
+          },
+        ],
+      },
+    }
+  end
+
+  def searchability_public
+    {
+      bool: {
+        must: [
+          {
+            exists: {
+              field: 'searchability',
+            },
+          },
+          {
+            term: { searchability: 'public' },
+          },
+        ],
+      },
+    }
+  end
+
+  def searchability_private
+    {
+      bool: {
+        must: [
+          {
+            exists: {
+              field: 'searchability',
+            },
+          },
+          {
+            term: { searchability: 'private' },
+          },
+          {
+            terms: { account_id: following_account_ids },
+          },
+        ],
+      },
+    }
+  end
+
+  def searchability_limited
+    {
+      bool: {
+        must: [
+          {
+            exists: {
+              field: 'searchability',
+            },
+          },
+          {
+            term: { searchability: 'limited' },
+          },
+          {
+            term: { account_id: @account.id },
+          },
+        ],
+      },
+    }
+  end
+
+  def following_account_ids
+    return @following_account_ids if defined?(@following_account_ids)
+
+    account_exists_sql     = Account.where('accounts.id = follows.target_account_id').where(searchability: %w(public private)).reorder(nil).select(1).to_sql
+    status_exists_sql      = Status.where('statuses.account_id = follows.target_account_id').where(reblog_of_id: nil).where(searchability: %w(public private)).reorder(nil).select(1).to_sql
+    following_accounts     = Follow.where(account_id: @account.id).merge(Account.where("EXISTS (#{account_exists_sql})").or(Account.where("EXISTS (#{status_exists_sql})")))
+    @following_account_ids = following_accounts.pluck(:target_account_id)
+  end
+
+  def parsed_query
+    SearchQueryTransformer.new.apply(SearchQueryParser.new.parse(@query))
+  end
+end