pagination.rb 7.56 KB
Newer Older
1
2
3
4
module API
  module Helpers
    module Pagination
      def paginate(relation)
5
        strategy = if params[:pagination] == 'keyset' && Feature.enabled?('api_keyset_pagination')
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
                     KeysetPaginationStrategy
                   else
                     DefaultPaginationStrategy
                   end

        strategy.new(self).paginate(relation)
      end

      class KeysetPaginationInfo
        attr_reader :relation, :request_context

        def initialize(relation, request_context)
          # This is because it's rather complex to support multiple values with possibly different sort directions
          # (and we don't need this in the API)
          if relation.order_values.size > 1
            raise "Pagination only supports ordering by a single column." \
              "The following columns were given: #{relation.order_values.map { |v| v.expr.name }}"
          end

          @relation = relation
          @request_context = request_context
        end

        def fields
          keys.zip(values).reject { |_, v| v.nil? }.to_h
        end

        def column_for_order_by(relation)
          relation.order_values.first&.expr&.name
        end

        # Sort direction (`:asc` or `:desc`)
        def sort
          @sort ||= if order_by_primary_key?
                      # Default order is by id DESC
                      :desc
                    else
                      # API defaults to DESC order if param `sort` not present
                      request_context.params[:sort]&.to_sym || :desc
                    end
        end

        # Do we only sort by primary key?
        def order_by_primary_key?
          keys.size == 1 && keys.first == primary_key
        end

        def primary_key
          relation.model.primary_key.to_sym
        end

        def sort_ascending?
          sort == :asc
        end

        # Build hash of request parameters for a given record (relevant to pagination)
        def params_for(record)
          return {} unless record

          keys.each_with_object({}) do |key, h|
            h["ks_prev_#{key}".to_sym] = record.attributes[key.to_s]
          end
        end

        private

        # All values present in request parameters that correspond to #keys.
        def values
          @values ||= keys.map do |key|
            request_context.params["ks_prev_#{key}".to_sym]
          end
        end

        # All keys relevant to pagination.
        # This always includes the primary key. Optionally, the `order_by` key is prepended.
        def keys
          @keys ||= [column_for_order_by(relation), primary_key].compact.uniq
        end
      end

      class KeysetPaginationStrategy
        attr_reader :request_context
        delegate :params, :header, :request, to: :request_context

        def initialize(request_context)
          @request_context = request_context
        end

94
        # rubocop: disable CodeReuse/ActiveRecord
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
        def paginate(relation)
          pagination = KeysetPaginationInfo.new(relation, request_context)

          paged_relation = relation.limit(per_page)

          if conds = conditions(pagination)
            paged_relation = paged_relation.where(*conds)
          end

          # In all cases: sort by primary key (possibly in addition to another sort column)
          paged_relation = paged_relation.order(pagination.primary_key => pagination.sort)

          add_default_pagination_headers

          if last_record = paged_relation.last
            next_page_params = pagination.params_for(last_record)
            add_navigation_links(next_page_params)
          end

          paged_relation
        end
116
        # rubocop: enable CodeReuse/ActiveRecord
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

        private

        def conditions(pagination)
          fields = pagination.fields

          return nil if fields.empty?

          placeholder = fields.map { '?' }

          comp = if pagination.sort_ascending?
                   '>'
                 else
                   '<'
                 end

          [
            # Row value comparison:
            # (A, B) < (a, b) <=> (A < a) OR (A = a AND B < b)
            #     <=> A <= a AND ((A < a) OR (A = a AND B < b))
            "(#{fields.keys.join(',')}) #{comp} (#{placeholder.join(',')})",
            *fields.values
          ]
        end

        def per_page
          params[:per_page]
        end

        def add_default_pagination_headers
          header 'X-Per-Page',    per_page.to_s
        end

        def add_navigation_links(next_page_params)
          header 'X-Next-Page', page_href(next_page_params)
          header 'Link', link_for('next', next_page_params)
        end

        def page_href(next_page_params)
          request_url = request.url.split('?').first
          request_params = params.dup
          request_params[:per_page] = per_page

          request_params.merge!(next_page_params) if next_page_params

          "#{request_url}?#{request_params.to_query}"
        end

        def link_for(rel, next_page_params)
          %(<#{page_href(next_page_params)}>; rel="#{rel}")
        end
168
169
      end

170
      class DefaultPaginationStrategy
171
172
        attr_reader :request_context
        delegate :params, :header, :request, to: :request_context
173

174
175
        def initialize(request_context)
          @request_context = request_context
176
        end
177

178
179
        def paginate(relation)
          relation = add_default_order(relation)
180

181
182
183
184
          relation.page(params[:page]).per(params[:per_page]).tap do |data|
            add_pagination_headers(data)
          end
        end
185

186
        private
187

188
        # rubocop: disable CodeReuse/ActiveRecord
189
190
191
192
        def add_default_order(relation)
          if relation.is_a?(ActiveRecord::Relation) && relation.order_values.empty?
            relation = relation.order(:id)
          end
193

194
195
          relation
        end
196
        # rubocop: enable CodeReuse/ActiveRecord
197

198
199
200
201
202
203
        def add_pagination_headers(paginated_data)
          header 'X-Per-Page',    paginated_data.limit_value.to_s
          header 'X-Page',        paginated_data.current_page.to_s
          header 'X-Next-Page',   paginated_data.next_page.to_s
          header 'X-Prev-Page',   paginated_data.prev_page.to_s
          header 'Link',          pagination_links(paginated_data)
204

205
          return if data_without_counts?(paginated_data)
206

207
208
          header 'X-Total',       paginated_data.total_count.to_s
          header 'X-Total-Pages', total_pages(paginated_data).to_s
209
        end
210

211
212
213
214
        def pagination_links(paginated_data)
          request_url = request.url.split('?').first
          request_params = params.clone
          request_params[:per_page] = paginated_data.limit_value
215

216
          links = []
217

218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
          request_params[:page] = paginated_data.prev_page
          links << %(<#{request_url}?#{request_params.to_query}>; rel="prev") if request_params[:page]

          request_params[:page] = paginated_data.next_page
          links << %(<#{request_url}?#{request_params.to_query}>; rel="next") if request_params[:page]

          request_params[:page] = 1
          links << %(<#{request_url}?#{request_params.to_query}>; rel="first")

          unless data_without_counts?(paginated_data)
            request_params[:page] = total_pages(paginated_data)
            links << %(<#{request_url}?#{request_params.to_query}>; rel="last")
          end

          links.join(', ')
233
234
        end

235
236
237
238
        def total_pages(paginated_data)
          # Ensure there is in total at least 1 page
          [paginated_data.total_pages, 1].max
        end
239

240
241
242
        def data_without_counts?(paginated_data)
          paginated_data.is_a?(Kaminari::PaginatableWithoutCount)
        end
243
      end
244
245
246
    end
  end
end