Rename Activity.Search to Search.DatabaseSearch

config/config.exs

@@ -870,7 +870,7 @@
   {Pleroma.Search, [max_running: 30, max_waiting: 50]}
 ]
 
-config :pleroma, Pleroma.Search, module: Pleroma.Activity.Search
+config :pleroma, Pleroma.Search, module: Pleroma.Search.DatabaseSearch
 
 config :pleroma, Pleroma.Search.Meilisearch, url: "http://127.0.0.1:7700/", private_key: nil
 

config/test.exs

@@ -133,7 +133,7 @@
   ap_streamer: Pleroma.Web.ActivityPub.ActivityPubMock,
   logger: Pleroma.LoggerMock
 
-config :pleroma, Pleroma.Search, module: Pleroma.Activity
+config :pleroma, Pleroma.Search, module: Pleroma.Search.DatabaseSearch
 
 config :pleroma, Pleroma.Search.Meilisearch, url: "http://127.0.0.1:7700/", private_key: nil
 

docs/configuration/search.md

@@ -6,7 +6,7 @@
 
 To use built-in search that has no external dependencies, set the search module to `Pleroma.Activity`:
 
-> config :pleroma, Pleroma.Search, module: Pleroma.Activity
+> config :pleroma, Pleroma.Search, module: Pleroma.Search.DatabaseSearch
 
 While it has no external dependencies, it has problems with performance and relevancy.
 

lib/pleroma/activity.ex

@@ -366,7 +366,7 @@ def restrict_deactivated_users(query) do
     from(activity in query, where: activity.actor not in subquery(deactivated_users_query))
   end
 
-  defdelegate search(user, query, options \\ []), to: Pleroma.Activity.Search
+  defdelegate search(user, query, options \\ []), to: Pleroma.Search.DatabaseSearch
 
   def direct_conversation_id(activity, for_user) do
     alias Pleroma.Conversation.Participation

lib/pleroma/activity/search.ex

@@ -1,165 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Activity.Search do
-  alias Pleroma.Activity
-  alias Pleroma.Object.Fetcher
-  alias Pleroma.Pagination
-  alias Pleroma.User
-  alias Pleroma.Web.ActivityPub.Visibility
-
-  require Pleroma.Constants
-
-  import Ecto.Query
-
-  def search(user, search_query, options \\ []) do
-    index_type = if Pleroma.Config.get([:database, :rum_enabled]), do: :rum, else: :gin
-    limit = Enum.min([Keyword.get(options, :limit), 40])
-    offset = Keyword.get(options, :offset, 0)
-    author = Keyword.get(options, :author)
-
-    search_function =
-      if :persistent_term.get({Pleroma.Repo, :postgres_version}) >= 11 do
-        :websearch
-      else
-        :plain
-      end
-
-    try do
-      Activity
-      |> Activity.with_preloaded_object()
-      |> Activity.restrict_deactivated_users()
-      |> restrict_public(user)
-      |> query_with(index_type, search_query, search_function)
-      |> maybe_restrict_local(user)
-      |> maybe_restrict_author(author)
-      |> maybe_restrict_blocked(user)
-      |> Pagination.fetch_paginated(
-        %{"offset" => offset, "limit" => limit, "skip_order" => index_type == :rum},
-        :offset
-      )
-      |> maybe_fetch(user, search_query)
-    rescue
-      _ -> maybe_fetch([], user, search_query)
-    end
-  end
-
-  def add_to_index(_activity), do: nil
-  def remove_from_index(_object), do: nil
-
-  def maybe_restrict_author(query, %User{} = author) do
-    Activity.Queries.by_author(query, author)
-  end
-
-  def maybe_restrict_author(query, _), do: query
-
-  def maybe_restrict_blocked(query, %User{} = user) do
-    Activity.Queries.exclude_authors(query, User.blocked_users_ap_ids(user))
-  end
-
-  def maybe_restrict_blocked(query, _), do: query
-
-  defp restrict_public(q, user) when not is_nil(user) do
-    intended_recipients = [
-      Pleroma.Constants.as_public(),
-      Pleroma.Web.ActivityPub.Utils.as_local_public()
-    ]
-
-    from([a, o] in q,
-      where: fragment("?->>'type' = 'Create'", a.data),
-      where: fragment("? && ?", ^intended_recipients, a.recipients)
-    )
-  end
-
-  defp restrict_public(q, _user) do
-    from([a, o] in q,
-      where: fragment("?->>'type' = 'Create'", a.data),
-      where: ^Pleroma.Constants.as_public() in a.recipients
-    )
-  end
-
-  defp query_with(q, :gin, search_query, :plain) do
-    %{rows: [[tsc]]} =
-      Ecto.Adapters.SQL.query!(
-        Pleroma.Repo,
-        "select current_setting('default_text_search_config')::regconfig::oid;"
-      )
-
-    from([a, o] in q,
-      where:
-        fragment(
-          "to_tsvector(?::oid::regconfig, ?->>'content') @@ plainto_tsquery(?)",
-          ^tsc,
-          o.data,
-          ^search_query
-        )
-    )
-  end
-
-  defp query_with(q, :gin, search_query, :websearch) do
-    %{rows: [[tsc]]} =
-      Ecto.Adapters.SQL.query!(
-        Pleroma.Repo,
-        "select current_setting('default_text_search_config')::regconfig::oid;"
-      )
-
-    from([a, o] in q,
-      where:
-        fragment(
-          "to_tsvector(?::oid::regconfig, ?->>'content') @@ websearch_to_tsquery(?)",
-          ^tsc,
-          o.data,
-          ^search_query
-        )
-    )
-  end
-
-  defp query_with(q, :rum, search_query, :plain) do
-    from([a, o] in q,
-      where:
-        fragment(
-          "? @@ plainto_tsquery(?)",
-          o.fts_content,
-          ^search_query
-        ),
-      order_by: [fragment("? <=> now()::date", o.inserted_at)]
-    )
-  end
-
-  defp query_with(q, :rum, search_query, :websearch) do
-    from([a, o] in q,
-      where:
-        fragment(
-          "? @@ websearch_to_tsquery(?)",
-          o.fts_content,
-          ^search_query
-        ),
-      order_by: [fragment("? <=> now()::date", o.inserted_at)]
-    )
-  end
-
-  def maybe_restrict_local(q, user) do
-    limit = Pleroma.Config.get([:instance, :limit_to_local_content], :unauthenticated)
-
-    case {limit, user} do
-      {:all, _} -> restrict_local(q)
-      {:unauthenticated, %User{}} -> q
-      {:unauthenticated, _} -> restrict_local(q)
-      {false, _} -> q
-    end
-  end
-
-  defp restrict_local(q), do: where(q, local: true)
-
-  def maybe_fetch(activities, user, search_query) do
-    with true <- Regex.match?(~r/https?:/, search_query),
-         {:ok, object} <- Fetcher.fetch_object_from_id(search_query),
-         %Activity{} = activity <- Activity.get_create_by_object_ap_id(object.data["id"]),
-         true <- Visibility.visible_for_user?(activity, user) do
-      [activity | activities]
-    else
-      _ -> activities
-    end
-  end
-end

lib/pleroma/search.ex

@@ -0,0 +1,24 @@
+defmodule Pleroma.Search do
+  def add_to_index(activity) do
+    search_module = Pleroma.Config.get([Pleroma.Search, :module])
+
+    ConcurrentLimiter.limit(Pleroma.Search, fn ->
+      Task.start(fn -> search_module.add_to_index(activity) end)
+    end)
+  end
+
+  def remove_from_index(object) do
+    # Also delete from search index
+    search_module = Pleroma.Config.get([Pleroma.Search, :module])
+
+    ConcurrentLimiter.limit(Pleroma.Search, fn ->
+      Task.start(fn -> search_module.remove_from_index(object) end)
+    end)
+  end
+
+  def search(query, options) do
+    search_module = Pleroma.Config.get([Pleroma.Search, :module], Pleroma.Activity)
+
+    search_module.search(options[:for_user], query, options)
+  end
+end

lib/pleroma/search/database_search.ex

@@ -1,24 +1,153 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
 defmodule Pleroma.Search.DatabaseSearch do
-  def add_to_index(activity) do
+  alias Pleroma.Activity
-    search_module = Pleroma.Config.get([Pleroma.Search, :module])
+  alias Pleroma.Object.Fetcher
+  alias Pleroma.Pagination
+  alias Pleroma.User
+  alias Pleroma.Web.ActivityPub.Visibility
 
-    ConcurrentLimiter.limit(Pleroma.Search, fn ->
+  require Pleroma.Constants
-      Task.start(fn -> search_module.add_to_index(activity) end)
+
-    end)
+  import Ecto.Query
+
+  def search(user, search_query, options \\ []) do
+    index_type = if Pleroma.Config.get([:database, :rum_enabled]), do: :rum, else: :gin
+    limit = Enum.min([Keyword.get(options, :limit), 40])
+    offset = Keyword.get(options, :offset, 0)
+    author = Keyword.get(options, :author)
+
+    search_function =
+      if :persistent_term.get({Pleroma.Repo, :postgres_version}) >= 11 do
+        :websearch
+      else
+        :plain
       end
 
-  def remove_from_index(object) do
+    try do
-    # Also delete from search index
+      Activity
-    search_module = Pleroma.Config.get([Pleroma.Search, :module])
+      |> Activity.with_preloaded_object()
-
+      |> Activity.restrict_deactivated_users()
-    ConcurrentLimiter.limit(Pleroma.Search, fn ->
+      |> restrict_public()
-      Task.start(fn -> search_module.remove_from_index(object) end)
+      |> query_with(index_type, search_query, search_function)
-    end)
+      |> maybe_restrict_local(user)
-  end
+      |> maybe_restrict_author(author)
-
+      |> maybe_restrict_blocked(user)
-  def search(query, options) do
+      |> Pagination.fetch_paginated(
-    search_module = Pleroma.Config.get([Pleroma.Search, :module], Pleroma.Activity)
+        %{"offset" => offset, "limit" => limit, "skip_order" => index_type == :rum},
-
+        :offset
-    search_module.search(options[:for_user], query, options)
+      )
+      |> maybe_fetch(user, search_query)
+    rescue
+      _ -> maybe_fetch([], user, search_query)
+    end
+  end
+
+  def add_to_index(_activity), do: nil
+  def remove_from_index(_object), do: nil
+
+  def maybe_restrict_author(query, %User{} = author) do
+    Activity.Queries.by_author(query, author)
+  end
+
+  def maybe_restrict_author(query, _), do: query
+
+  def maybe_restrict_blocked(query, %User{} = user) do
+    Activity.Queries.exclude_authors(query, User.blocked_users_ap_ids(user))
+  end
+
+  def maybe_restrict_blocked(query, _), do: query
+
+  def restrict_public(q) do
+    from([a, o] in q,
+      where: fragment("?->>'type' = 'Create'", a.data),
+      where: ^Pleroma.Constants.as_public() in a.recipients
+    )
+  end
+
+  defp query_with(q, :gin, search_query, :plain) do
+    %{rows: [[tsc]]} =
+      Ecto.Adapters.SQL.query!(
+        Pleroma.Repo,
+        "select current_setting('default_text_search_config')::regconfig::oid;"
+      )
+
+    from([a, o] in q,
+      where:
+        fragment(
+          "to_tsvector(?::oid::regconfig, ?->>'content') @@ plainto_tsquery(?)",
+          ^tsc,
+          o.data,
+          ^search_query
+        )
+    )
+  end
+
+  defp query_with(q, :gin, search_query, :websearch) do
+    %{rows: [[tsc]]} =
+      Ecto.Adapters.SQL.query!(
+        Pleroma.Repo,
+        "select current_setting('default_text_search_config')::regconfig::oid;"
+      )
+
+    from([a, o] in q,
+      where:
+        fragment(
+          "to_tsvector(?::oid::regconfig, ?->>'content') @@ websearch_to_tsquery(?)",
+          ^tsc,
+          o.data,
+          ^search_query
+        )
+    )
+  end
+
+  defp query_with(q, :rum, search_query, :plain) do
+    from([a, o] in q,
+      where:
+        fragment(
+          "? @@ plainto_tsquery(?)",
+          o.fts_content,
+          ^search_query
+        ),
+      order_by: [fragment("? <=> now()::date", o.inserted_at)]
+    )
+  end
+
+  defp query_with(q, :rum, search_query, :websearch) do
+    from([a, o] in q,
+      where:
+        fragment(
+          "? @@ websearch_to_tsquery(?)",
+          o.fts_content,
+          ^search_query
+        ),
+      order_by: [fragment("? <=> now()::date", o.inserted_at)]
+    )
+  end
+
+  def maybe_restrict_local(q, user) do
+    limit = Pleroma.Config.get([:instance, :limit_to_local_content], :unauthenticated)
+
+    case {limit, user} do
+      {:all, _} -> restrict_local(q)
+      {:unauthenticated, %User{}} -> q
+      {:unauthenticated, _} -> restrict_local(q)
+      {false, _} -> q
+    end
+  end
+
+  defp restrict_local(q), do: where(q, local: true)
+
+  def maybe_fetch(activities, user, search_query) do
+    with true <- Regex.match?(~r/https?:/, search_query),
+         {:ok, object} <- Fetcher.fetch_object_from_id(search_query),
+         %Activity{} = activity <- Activity.get_create_by_object_ap_id(object.data["id"]),
+         true <- Visibility.visible_for_user?(activity, user) do
+      [activity | activities]
+    else
+      _ -> activities
+    end
   end
 end

lib/pleroma/search/meilisearch.ex

@@ -4,7 +4,7 @@ defmodule Pleroma.Search.Meilisearch do
 
   alias Pleroma.Activity
 
-  import Pleroma.Activity.Search
+  import Pleroma.Search.DatabaseSearch
   import Ecto.Query
 
   defp meili_headers do

lib/pleroma/web/activity_pub/activity_pub.ex

@@ -141,7 +141,7 @@ def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when
       end)
 
       # Add local posts to search index
-      if local, do: Pleroma.Search.DatabaseSearch.add_to_index(activity)
+      if local, do: Pleroma.Search.add_to_index(activity)
 
       {:ok, activity}
     else

lib/pleroma/web/activity_pub/side_effects.ex

@@ -227,7 +227,7 @@ def handle(%{data: %{"type" => "Create"}} = activity, meta) do
         Task.start(fn -> Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity) end)
       end)
 
-      Pleroma.Search.DatabaseSearch.add_to_index(Map.put(activity, :object, object))
+      Pleroma.Search.add_to_index(Map.put(activity, :object, object))
 
       meta =
         meta
@@ -330,7 +330,7 @@ def handle(%{data: %{"type" => "Delete", "object" => deleted_object}} = object,
     if result == :ok do
       Notification.create_notifications(object)
 
-      Pleroma.Search.DatabaseSearch.remove_from_index(deleted_object)
+      Pleroma.Search.remove_from_index(deleted_object)
 
       {:ok, object, meta}
     else

lib/pleroma/web/mastodon_api/controllers/search_controller.ex

@@ -99,7 +99,7 @@ defp resource_search(_, "accounts", query, options) do
   end
 
   defp resource_search(_, "statuses", query, options) do
-    statuses = with_fallback(fn -> Pleroma.Search.DatabaseSearch.search(query, options) end)
+    statuses = with_fallback(fn -> Pleroma.Search.search(query, options) end)
 
     StatusView.render("index.json",
       activities: statuses,

test/pleroma/search/database_search_test.ex

@@ -2,8 +2,8 @@
 # Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 
-defmodule Pleroma.Activity.SearchTest do
+defmodule Pleroma.Search.DatabaseSearchTest do
-  alias Pleroma.Activity.Search
+  alias Pleroma.Search.DatabaseSearch
   alias Pleroma.Web.CommonAPI
   import Pleroma.Factory
 
@@ -13,7 +13,7 @@ test "it finds something" do
     user = insert(:user)
     {:ok, post} = CommonAPI.post(user, %{status: "it's wednesday my dudes"})
 
-    [result] = Search.search(nil, "wednesday")
+    [result] = DatabaseSearch.search(nil, "wednesday")
 
     assert result.id == post.id
   end
@@ -45,7 +45,7 @@ test "using plainto_tsquery on postgres < 11" do
     {:ok, _post2} = CommonAPI.post(user, %{status: "it's wednesday my bros"})
 
     # plainto doesn't understand complex queries
-    assert [result] = Search.search(nil, "wednesday -dudes")
+    assert [result] = DatabaseSearch.search(nil, "wednesday -dudes")
 
     assert result.id == post.id
   end
@@ -55,7 +55,7 @@ test "using websearch_to_tsquery" do
     {:ok, _post} = CommonAPI.post(user, %{status: "it's wednesday my dudes"})
     {:ok, other_post} = CommonAPI.post(user, %{status: "it's wednesday my bros"})
 
-    assert [result] = Search.search(nil, "wednesday -dudes")
+    assert [result] = DatabaseSearch.search(nil, "wednesday -dudes")
 
     assert result.id == other_post.id
   end