128 lines
3.7 KiB
Ruby
128 lines
3.7 KiB
Ruby
module Connections
|
|
class CursorConnection < GraphQL::Pagination::Connection
|
|
def initialize(items, deprecated_order: nil, **kwargs)
|
|
super(items, **kwargs)
|
|
@deprecated_order = deprecated_order
|
|
end
|
|
|
|
def nodes
|
|
load_nodes
|
|
end
|
|
|
|
def has_previous_page
|
|
load_nodes
|
|
@has_previous_page
|
|
end
|
|
|
|
def has_next_page
|
|
load_nodes
|
|
@has_next_page
|
|
end
|
|
|
|
def cursor_for(item)
|
|
cursor_from_column(item, order_column)
|
|
end
|
|
|
|
private
|
|
|
|
def load_nodes
|
|
@nodes ||= begin
|
|
ensure_valid_params
|
|
|
|
limit = compute_limit(first:, last:)
|
|
expected_size = limit - 1
|
|
|
|
page_info = compute_page_info(limit:, before:, after:, first:, last:)
|
|
nodes = resolve_nodes(limit:, **page_info.slice(:before, :after, :inverted))
|
|
|
|
result_size = nodes.size
|
|
@has_previous_page = page_info[:has_previous_page].(result_size)
|
|
@has_next_page = page_info[:has_next_page].(result_size)
|
|
|
|
trimmed_nodes = nodes.first(expected_size)
|
|
trimmed_nodes.reverse! if page_info[:inverted]
|
|
trimmed_nodes
|
|
end
|
|
end
|
|
|
|
def ensure_valid_params
|
|
if first.present? && last.present?
|
|
raise GraphQL::ExecutionError.new('Arguments "first" and "last" are exclusive', extensions: { code: :bad_request })
|
|
end
|
|
|
|
if before.present? && after.present?
|
|
raise GraphQL::ExecutionError.new('Arguments "before" and "after" are exclusive', extensions: { code: :bad_request })
|
|
end
|
|
|
|
if first.present? && first < 0
|
|
raise GraphQL::ExecutionError.new('Argument "first" must be a non-negative integer', extensions: { code: :bad_request })
|
|
end
|
|
|
|
if last.present? && last < 0
|
|
raise GraphQL::ExecutionError.new('Argument "last" must be a non-negative integer', extensions: { code: :bad_request })
|
|
end
|
|
end
|
|
|
|
def compute_limit(first: nil, last: nil)
|
|
[first || last || default_page_size].min + 1
|
|
end
|
|
|
|
def timestamp_and_id_from_cursor(cursor)
|
|
timestamp, id = decode(cursor).split(';')
|
|
[Time.zone.parse(timestamp), id.to_i]
|
|
end
|
|
|
|
def cursor_from_column(item, column)
|
|
encode([item.read_attribute(column).utc.strftime("%Y-%m-%dT%H:%M:%S.%NZ"), item.id].join(';'))
|
|
end
|
|
|
|
def order_column
|
|
:updated_at
|
|
end
|
|
|
|
def order_table
|
|
raise StandardError, 'Not implemented'
|
|
end
|
|
|
|
def resolve_nodes(before:, after:, limit:, inverted:)
|
|
order = inverted ? :desc : :asc
|
|
nodes = items.order(order_column => order, id: order)
|
|
nodes = nodes.limit(limit)
|
|
|
|
if before.present?
|
|
timestamp, id = timestamp_and_id_from_cursor(before)
|
|
nodes.where("(#{order_table}.#{order_column}, #{order_table}.id) < (?, ?)", timestamp, id)
|
|
elsif after.present?
|
|
timestamp, id = timestamp_and_id_from_cursor(after)
|
|
nodes.where("(#{order_table}.#{order_column}, #{order_table}.id) > (?, ?)", timestamp, id)
|
|
else
|
|
nodes
|
|
end
|
|
end
|
|
|
|
# before and after are a serialized version of (timestamp, id)
|
|
# first is a number (n) and mean take n element in order ascendant
|
|
# last : n element in order descendant
|
|
def compute_page_info(limit:, before: nil, after: nil, first: nil, last: nil)
|
|
if @deprecated_order == :desc
|
|
if last.present?
|
|
first = [last, max_page_size].min
|
|
last = nil
|
|
else
|
|
last = [first || default_page_size].min
|
|
first = nil
|
|
end
|
|
end
|
|
|
|
inverted = last.present? || before.present?
|
|
|
|
{
|
|
before:,
|
|
after:,
|
|
inverted:,
|
|
has_previous_page: -> (result_size) { after.present? || (result_size >= limit && inverted) },
|
|
has_next_page: -> (result_size) { before.present? || (result_size >= limit && !inverted) }
|
|
}
|
|
end
|
|
end
|
|
end
|