git.squeep.com Git - akkoma/blob - lib/pleroma/pagination.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Pagination do
   6   @moduledoc """
   7   Implements Mastodon-compatible pagination.
   8   """
   9
  10   import Ecto.Query
  11   import Ecto.Changeset
  12
  13   alias Pleroma.Repo
  14
  15   @default_limit 20
  16
  17   def fetch_paginated(query, params, type \\ :keyset)
  18
  19   def fetch_paginated(query, params, :keyset) do
  20     options = cast_params(params)
  21     total = Repo.aggregate(query, :count, :id)
  22
  23     %{
  24       total: total,
  25       items:
  26         query
  27         |> paginate(options, :keyset)
  28         |> Repo.all()
  29         |> enforce_order(options)
  30     }
  31   end
  32
  33   def fetch_paginated(query, params, :offset) do
  34     options = cast_params(params)
  35     total = Repo.aggregate(query, :count, :id)
  36
  37     %{
  38       total: total,
  39       items:
  40         query
  41         |> paginate(options, :offset)
  42         |> Repo.all()
  43     }
  44   end
  45
  46   def paginate(query, options, method \\ :keyset)
  47
  48   def paginate(query, options, :keyset) do
  49     query
  50     |> restrict(:min_id, options)
  51     |> restrict(:since_id, options)
  52     |> restrict(:max_id, options)
  53     |> restrict(:order, options)
  54     |> restrict(:limit, options)
  55   end
  56
  57   def paginate(query, options, :offset) do
  58     query
  59     |> restrict(:offset, options)
  60     |> restrict(:limit, options)
  61   end
  62
  63   defp cast_params(params) do
  64     param_types = %{
  65       min_id: :string,
  66       since_id: :string,
  67       max_id: :string,
  68       offset: :integer,
  69       limit: :integer
  70     }
  71
  72     params =
  73       Enum.reduce(params, %{}, fn
  74         {key, _value}, acc when is_atom(key) -> Map.drop(acc, [key])
  75         {key, value}, acc -> Map.put(acc, key, value)
  76       end)
  77
  78     changeset = cast({%{}, param_types}, params, Map.keys(param_types))
  79     changeset.changes
  80   end
  81
  82   defp restrict(query, :min_id, %{min_id: min_id}) do
  83     where(query, [q], q.id > ^min_id)
  84   end
  85
  86   defp restrict(query, :since_id, %{since_id: since_id}) do
  87     where(query, [q], q.id > ^since_id)
  88   end
  89
  90   defp restrict(query, :max_id, %{max_id: max_id}) do
  91     where(query, [q], q.id < ^max_id)
  92   end
  93
  94   defp restrict(query, :order, %{min_id: _}) do
  95     order_by(query, [u], fragment("? asc nulls last", u.id))
  96   end
  97
  98   defp restrict(query, :order, _options) do
  99     order_by(query, [u], fragment("? desc nulls last", u.id))
 100   end
 101
 102   defp restrict(query, :offset, %{offset: offset}) do
 103     offset(query, ^offset)
 104   end
 105
 106   defp restrict(query, :limit, options) do
 107     limit = Map.get(options, :limit, @default_limit)
 108
 109     query
 110     |> limit(^limit)
 111   end
 112
 113   defp restrict(query, _, _), do: query
 114
 115   defp enforce_order(result, %{min_id: _}) do
 116     result
 117     |> Enum.reverse()
 118   end
 119
 120   defp enforce_order(result, _), do: result
 121 end