Commit 4d3b313a authored by Yorick Peterse's avatar Yorick Peterse

Merge branch 'ab-42194-keyset-pagination' into 'master'

API: Keyset pagination support

Closes #45756

See merge request gitlab-org/gitlab-ce!18584
parents 2c7095c8 f5c42031
...@@ -2,67 +2,240 @@ module API ...@@ -2,67 +2,240 @@ module API
module Helpers module Helpers
module Pagination module Pagination
def paginate(relation) def paginate(relation)
relation = add_default_order(relation) strategy = if params[:pagination] == 'keyset' && Feature.enabled?('api_keyset_pagination')
KeysetPaginationStrategy
else
DefaultPaginationStrategy
end
relation.page(params[:page]).per(params[:per_page]).tap do |data| strategy.new(self).paginate(relation)
add_pagination_headers(data)
end
end end
private class KeysetPaginationInfo
attr_reader :relation, :request_context
def add_pagination_headers(paginated_data) def initialize(relation, request_context)
header 'X-Per-Page', paginated_data.limit_value.to_s # This is because it's rather complex to support multiple values with possibly different sort directions
header 'X-Page', paginated_data.current_page.to_s # (and we don't need this in the API)
header 'X-Next-Page', paginated_data.next_page.to_s if relation.order_values.size > 1
header 'X-Prev-Page', paginated_data.prev_page.to_s raise "Pagination only supports ordering by a single column." \
header 'Link', pagination_links(paginated_data) "The following columns were given: #{relation.order_values.map { |v| v.expr.name }}"
end
return if data_without_counts?(paginated_data) @relation = relation
@request_context = request_context
end
header 'X-Total', paginated_data.total_count.to_s def fields
header 'X-Total-Pages', total_pages(paginated_data).to_s keys.zip(values).reject { |_, v| v.nil? }.to_h
end end
def pagination_links(paginated_data) def column_for_order_by(relation)
request_url = request.url.split('?').first relation.order_values.first&.expr&.name
request_params = params.clone end
request_params[:per_page] = paginated_data.limit_value
links = [] # 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
request_params[:page] = paginated_data.prev_page # Do we only sort by primary key?
links << %(<#{request_url}?#{request_params.to_query}>; rel="prev") if request_params[:page] def order_by_primary_key?
keys.size == 1 && keys.first == primary_key
end
request_params[:page] = paginated_data.next_page def primary_key
links << %(<#{request_url}?#{request_params.to_query}>; rel="next") if request_params[:page] relation.model.primary_key.to_sym
end
request_params[:page] = 1 def sort_ascending?
links << %(<#{request_url}?#{request_params.to_query}>; rel="first") sort == :asc
end
unless data_without_counts?(paginated_data) # Build hash of request parameters for a given record (relevant to pagination)
request_params[:page] = total_pages(paginated_data) def params_for(record)
links << %(<#{request_url}?#{request_params.to_query}>; rel="last") return {} unless record
keys.each_with_object({}) do |key, h|
h["ks_prev_#{key}".to_sym] = record.attributes[key.to_s]
end
end end
links.join(', ') private
end
# 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
def total_pages(paginated_data) # All keys relevant to pagination.
# Ensure there is in total at least 1 page # This always includes the primary key. Optionally, the `order_by` key is prepended.
[paginated_data.total_pages, 1].max def keys
@keys ||= [column_for_order_by(relation), primary_key].compact.uniq
end
end end
def add_default_order(relation) class KeysetPaginationStrategy
if relation.is_a?(ActiveRecord::Relation) && relation.order_values.empty? attr_reader :request_context
relation = relation.order(:id) delegate :params, :header, :request, to: :request_context
def initialize(request_context)
@request_context = request_context
end
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
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 end
relation 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
end end
def data_without_counts?(paginated_data) class DefaultPaginationStrategy
paginated_data.is_a?(Kaminari::PaginatableWithoutCount) attr_reader :request_context
delegate :params, :header, :request, to: :request_context
def initialize(request_context)
@request_context = request_context
end
def paginate(relation)
relation = add_default_order(relation)
relation.page(params[:page]).per(params[:per_page]).tap do |data|
add_pagination_headers(data)
end
end
private
def add_default_order(relation)
if relation.is_a?(ActiveRecord::Relation) && relation.order_values.empty?
relation = relation.order(:id)
end
relation
end
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)
return if data_without_counts?(paginated_data)
header 'X-Total', paginated_data.total_count.to_s
header 'X-Total-Pages', total_pages(paginated_data).to_s
end
def pagination_links(paginated_data)
request_url = request.url.split('?').first
request_params = params.clone
request_params[:per_page] = paginated_data.limit_value
links = []
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(', ')
end
def total_pages(paginated_data)
# Ensure there is in total at least 1 page
[paginated_data.total_pages, 1].max
end
def data_without_counts?(paginated_data)
paginated_data.is_a?(Kaminari::PaginatableWithoutCount)
end
end end
end end
end end
......
...@@ -17,8 +17,6 @@ module Gitlab ...@@ -17,8 +17,6 @@ module Gitlab
end end
end end
private
# Methods needed by `API::Helpers::Pagination` # Methods needed by `API::Helpers::Pagination`
# #
......
...@@ -7,7 +7,203 @@ describe API::Helpers::Pagination do ...@@ -7,7 +7,203 @@ describe API::Helpers::Pagination do
Class.new.include(described_class).new Class.new.include(described_class).new
end end
describe '#paginate' do describe '#paginate (keyset pagination)' do
let(:value) { spy('return value') }
before do
allow(value).to receive(:to_query).and_return(value)
allow(subject).to receive(:header).and_return(value)
allow(subject).to receive(:params).and_return(value)
allow(subject).to receive(:request).and_return(value)
end
context 'when resource can be paginated' do
let!(:projects) do
[
create(:project, name: 'One'),
create(:project, name: 'Two'),
create(:project, name: 'Three')
].sort_by { |e| -e.id } # sort by id desc (this is the default sort order for the API)
end
describe 'first page' do
before do
allow(subject).to receive(:params)
.and_return({ pagination: 'keyset', per_page: 2 })
end
it 'returns appropriate amount of resources' do
expect(subject.paginate(resource).count).to eq 2
end
it 'returns the first two records (by id desc)' do
expect(subject.paginate(resource)).to eq(projects[0..1])
end
it 'adds appropriate headers' do
expect_header('X-Per-Page', '2')
expect_header('X-Next-Page', "#{value}?ks_prev_id=#{projects[1].id}&pagination=keyset&per_page=2")
expect_header('Link', anything) do |_key, val|
expect(val).to include('rel="next"')
end
subject.paginate(resource)
end
end
describe 'second page' do
before do
allow(subject).to receive(:params)
.and_return({ pagination: 'keyset', per_page: 2, ks_prev_id: projects[1].id })
end
it 'returns appropriate amount of resources' do
expect(subject.paginate(resource).count).to eq 1
end
it 'returns the third record' do
expect(subject.paginate(resource)).to eq(projects[2..2])
end
it 'adds appropriate headers' do
expect_header('X-Per-Page', '2')
expect_header('X-Next-Page', "#{value}?ks_prev_id=#{projects[2].id}&pagination=keyset&per_page=2")
expect_header('Link', anything) do |_key, val|
expect(val).to include('rel="next"')
end
subject.paginate(resource)
end
end
describe 'third page' do
before do
allow(subject).to receive(:params)
.and_return({ pagination: 'keyset', per_page: 2, ks_prev_id: projects[2].id })
end
it 'returns appropriate amount of resources' do
expect(subject.paginate(resource).count).to eq 0
end
it 'adds appropriate headers' do
expect_header('X-Per-Page', '2')
expect(subject).not_to receive(:header).with('Link')
subject.paginate(resource)
end
end
context 'if order' do
context 'is not present' do
before do
allow(subject).to receive(:params)
.and_return({ pagination: 'keyset', per_page: 2 })
end
it 'is not present it adds default order(:id) desc' do
resource.order_values = []
paginated_relation = subject.paginate(resource)
expect(resource.order_values).to be_empty
expect(paginated_relation.order_values).to be_present
expect(paginated_relation.order_values.size).to eq(1)
expect(paginated_relation.order_values.first).to be_descending
expect(paginated_relation.order_values.first.expr.name).to eq :id
end
end
context 'is present' do
let(:resource) { Project.all.order(name: :desc) }
let!(:projects) do
[
create(:project, name: 'One'),
create(:project, name: 'Two'),
create(:project, name: 'Three'),
create(:project, name: 'Three'), # Note the duplicate name
create(:project, name: 'Four'),
create(:project, name: 'Five'),
create(:project, name: 'Six')
]
# if we sort this by name descending, id descending, this yields:
# {
# 2 => "Two",
# 4 => "Three",
# 3 => "Three",
# 7 => "Six",
# 1 => "One",
# 5 => "Four",
# 6 => "Five"
# }
#
# (key is the id)
end
it 'it also orders by primary key' do
allow(subject).to receive(:params)
.and_return({ pagination: 'keyset', per_page: 2 })
paginated_relation = subject.paginate(resource)
expect(paginated_relation.order_values).to be_present
expect(paginated_relation.order_values.size).to eq(2)
expect(paginated_relation.order_values.first).to be_descending
expect(paginated_relation.order_values.first.expr.name).to eq :name
expect(paginated_relation.order_values.second).to be_descending
expect(paginated_relation.order_values.second.expr.name).to eq :id
end
it 'it returns the right records (first page)' do
allow(subject).to receive(:params)
.and_return({ pagination: 'keyset', per_page: 2 })
result = subject.paginate(resource)
expect(result.first).to eq(projects[1])
expect(result.second).to eq(projects[3])
end
it 'it returns the right records (second page)' do
allow(subject).to receive(:params)
.and_return({ pagination: 'keyset', ks_prev_id: projects[3].id, ks_prev_name: projects[3].name, per_page: 2 })
result = subject.paginate(resource)
expect(result.first).to eq(projects[2])
expect(result.second).to eq(projects[6])
end
it 'it returns the right records (third page), note increased per_page' do
allow(subject).to receive(:params)
.and_return({ pagination: 'keyset', ks_prev_id: projects[6].id, ks_prev_name: projects[6].name, per_page: 5 })
result = subject.paginate(resource)
expect(result.size).to eq(3)
expect(result.first).to eq(projects[0])
expect(result.second).to eq(projects[4])
expect(result.last).to eq(projects[5])
end
it 'it returns the right link to the next page' do
allow(subject).to receive(:params)
.and_return({ pagination: 'keyset', ks_prev_id: projects[3].id, ks_prev_name: projects[3].name, per_page: 2 })
expect_header('X-Per-Page', '2')
expect_header('X-Next-Page', "#{value}?ks_prev_id=#{projects[6].id}&ks_prev_name=#{projects[6].name}&pagination=keyset&per_page=2")
expect_header('Link', anything) do |_key, val|
expect(val).to include('rel="next"')
end
subject.paginate(resource)
end
end
end
end
end
describe '#paginate (default offset-based pagination)' do
let(:value) { spy('return value') } let(:value) { spy('return value') }
before do before do
...@@ -146,14 +342,14 @@ describe API::Helpers::Pagination do ...@@ -146,14 +342,14 @@ describe API::Helpers::Pagination do
end end
end end
end end
end
def expect_header(*args, &block) def expect_header(*args, &block)
expect(subject).to receive(:header).with(*args, &block) expect(subject).to receive(:header).with(*args, &block)
end end
def expect_message(method) def expect_message(method)
expect(subject).to receive(method) expect(subject).to receive(method)
.at_least(:once).and_return(value) .at_least(:once).and_return(value)
end
end end
end end
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment