pleroma/lib/pleroma/search/meilisearch.ex

defmodule Pleroma.Search.Meilisearch do
  require Logger
  require Pleroma.Constants

  alias Pleroma.Activity
  alias Pleroma.Config.Getting, as: Config
  alias Pleroma.Object
  alias Pleroma.Search

  import Pleroma.Search.DatabaseSearch
  import Ecto.Query

  @behaviour Pleroma.Search.SearchBackend

  @impl true
  def create_index, do: :ok

  @impl true
  def drop_index, do: :ok

  defp meili_headers do
    private_key = Config.get([Pleroma.Search.Meilisearch, :private_key])

    [{"Content-Type", "application/json"}] ++
      if is_nil(private_key), do: [], else: [{"Authorization", "Bearer #{private_key}"}]
  end

  def meili_get(path) do
    endpoint = Config.get([Pleroma.Search.Meilisearch, :url])

    result =
      Pleroma.HTTP.get(
        Path.join(endpoint, path),
        meili_headers()
      )

    with {:ok, res} <- result do
      {:ok, Jason.decode!(res.body)}
    end
  end

  def meili_post(path, params) do
    endpoint = Config.get([Pleroma.Search.Meilisearch, :url])

    result =
      Pleroma.HTTP.post(
        Path.join(endpoint, path),
        Jason.encode!(params),
        meili_headers()
      )

    with {:ok, res} <- result do
      {:ok, Jason.decode!(res.body)}
    end
  end

  def meili_put(path, params) do
    endpoint = Config.get([Pleroma.Search.Meilisearch, :url])

    result =
      Pleroma.HTTP.request(
        :put,
        Path.join(endpoint, path),
        Jason.encode!(params),
        meili_headers(),
        []
      )

    with {:ok, res} <- result do
      {:ok, Jason.decode!(res.body)}
    end
  end

  def meili_delete(path) do
    endpoint = Config.get([Pleroma.Search.Meilisearch, :url])

    with {:ok, _} <-
           Pleroma.HTTP.request(
             :delete,
             Path.join(endpoint, path),
             "",
             meili_headers(),
             []
           ) do
      :ok
    else
      _ -> {:error, "Could not remove from index"}
    end
  end

  @impl true
  def search(user, query, options \\ []) do
    limit = Enum.min([Keyword.get(options, :limit), 40])
    offset = Keyword.get(options, :offset, 0)
    author = Keyword.get(options, :author)

    res =
      meili_post(
        "/indexes/objects/search",
        %{q: query, offset: offset, limit: limit}
      )

    with {:ok, result} <- res do
      hits = result["hits"] |> Enum.map(& &1["ap"])

      try do
        hits
        |> Activity.create_by_object_ap_id()
        |> Activity.with_preloaded_object()
        |> Activity.restrict_deactivated_users()
        |> maybe_restrict_local(user)
        |> maybe_restrict_author(author)
        |> maybe_restrict_blocked(user)
        |> maybe_fetch(user, query)
        |> order_by([object: obj], desc: obj.data["published"])
        |> Pleroma.Repo.all()
      rescue
        _ -> maybe_fetch([], user, query)
      end
    end
  end

  @impl true
  def add_to_index(%Activity{object: %Object{} = object} = activity) do
    search_data = Search.object_to_search_data(object)

    result =
      meili_put(
        "/indexes/objects/documents",
        [search_data]
      )

    with {:ok, %{"status" => "enqueued"}} <- result do
      # Added successfully
      :ok
    else
      _ ->
        # There was an error, report it
        Logger.error("Failed to add activity #{activity.id} to index: #{inspect(result)}")
        {:error, result}
    end
  end

  @impl true
  def remove_from_index(object) do
    meili_delete("/indexes/objects/documents/#{object.id}")
  end

  @impl true
  def healthcheck_endpoints do
    endpoint =
      Config.get([Pleroma.Search.Meilisearch, :url])
      |> URI.parse()
      |> Map.put(:path, "/health")
      |> URI.to_string()

    [endpoint]
  end
end