I found a way to do it without a second request. My pagination structure is like this:

pub struct Pagination<T> {
    cursor: Option<Cursor<T>>,
    page_size: u64,
    is_forward: bool,
}

Let's say that is_forward is true: for the very first page, the cursor is set to None (I use id = 0 or name = '' in that case internally). When I navigate forward, then now the cursor is set to something.

• To know if there is a next page, I query page_size + 1. If there are indeed page_size + 1 results, it means that there is a next page. Then I pop the last result, and use the new last item as cursor.
• To know if there is a previous page, I look at the cursor and is_forward from the request. If is_forward is true and cursor is Some, it means that there is a previous page. The idea is that if you come from another previous page, then there is a previous page, obviously.

Concretely, it means that every new cursor needs the previous one to be built, so I have a method like this:

impl<T> Pagination<T> {
    pub fn to_response(
        self,
        mut page: VecDeque<<Cursor<T> as CursorUpdatable>::Model>,
    ) -> PaginatedResponse<<Cursor<T> as CursorUpdatable>::Model>
    where
        Cursor<T>: CursorUpdatable,
        T: Default + Serialize,
    {
        let (has_next_page, has_prev_page) = if self.order() == Order::Asc {
            (page.len() as u64 > self.page_size(), self.cursor.is_some())
        } else {
            (self.cursor.is_some(), page.len() as u64 > self.page_size())
        };

        if self.order() == Order::Asc && has_next_page {
            let _ = page.pop_back();
        } else if self.order() == Order::Desc && has_prev_page {
            let _ = page.pop_front();
        }

        let cursor = self.cursor.unwrap_or_default();
        let start_cursor = page
            .front()
            .filter(|_| has_prev_page)
            .map(|first| cursor.new_from(first).encode());
        let end_cursor = page
            .back()
            .filter(|_| has_next_page)
            .map(|last| cursor.new_from(last).encode());

        PaginatedResponse {
            page,
            start_cursor,
            end_cursor,
        }
    }
}

I hope that this post can help people doing this for the first time and struggling to find an elegant solution.

There is one last thing to figure out: the corner case where some items are deleted is not handled by sear-orm. Let's say I query 5 items, A B C D E, I press next F G H I J then someone deletes A and B: now when I press previous, I want to see C D E F G, not C D E only. I know it's possible to handle this in a single query with a check over the count + direction (previous) + an UNION ALL against the first page, but I've no clue how to do this with sea-orm.