class GraphQL::Relay::RelationConnection

  • ‘Sequel::Dataset`
    - `ActiveRecord::Relation`
    It works for:
    A connection implementation to expose SQL collection objects.

def cursor_from_node(item) 

def cursor_from_node(item)
  offset = starting_offset + paged_nodes_array.index(item) + 1
  Base64.strict_encode64(offset.to_s)
end

def has_next_page 

def has_next_page
  !!(first && sliced_nodes.limit(limit + 1).count > limit)
end

def has_previous_page 

def has_previous_page
  !!(last && starting_offset > 0)
end

def limit

- otherwise, don't limit
- don't exceed max_page_size
- find a value from the query
Limit to apply to this query: 
def limit
  @limit ||= begin
    limit_from_arguments = if first
      first
    else
      if previous_offset < 0
        previous_offset + (last ? last : 0)
      else
        last
      end
    end
    [limit_from_arguments, max_page_size].compact.min
  end
end

def offset_from_cursor(cursor) 

def offset_from_cursor(cursor)
  Base64.decode64(cursor).to_i
end

def paged_nodes

apply first / last limit results 
def paged_nodes
  @paged_nodes ||= sliced_nodes.limit(limit)
end

def paged_nodes_array 

def paged_nodes_array
  @paged_nodes_array ||= paged_nodes.to_a
end

def previous_offset

Otherwise, zero
Offset from the previous selection, if there was one 
def previous_offset
  @previous_offset ||= if after
    offset_from_cursor(after)
  elsif before
    prev_page_size = [max_page_size, last].compact.min || 0
    offset_from_cursor(before) - prev_page_size - 1
  else
    0
  end
end

def sliced_nodes

Apply cursors to edges 
def sliced_nodes
  @sliced_nodes ||= nodes.offset(starting_offset)
end

def starting_offset 

def starting_offset
  @starting_offset ||= begin
    if before
      [previous_offset, 0].max
    else
      previous_offset
    end
  end
end