Implement the next page of an order feed without `Skip` or an offset.

Return OrderFeedItem rows ordered by CreatedAtUtc DESC, Id DESC, where Id is a long database key. The first page has no cursor. Later requests provide both values from the previous page's last row. Deleted orders are excluded.

After cursor (10:00, 42), include rows before 10:00 and rows at 10:00 whose id is lower than 42. A newer row inserted between requests does not shift the next page.

• Order.Id and OrderCursor.OrderId are long in this exercise.
• Both cursor fields are absent or both are present.
• Use comparisons matching descending order.
• Request one extra row to determine whether another page exists.
• Encode the outgoing cursor as an opaque API value.
• If the real identifier is not orderable in portable LINQ, add a stable ordered tie-breaker and verify provider translation.

I build the base query and add the compound cursor predicate only for later pages. Fetching pageSize + 1 avoids a separate count query. I return the requested rows and build the next cursor from the last returned item only when the extra row proves more data exists.

public sealed record OrderCursor(DateTimeOffset CreatedAtUtc, long OrderId);
public sealed record OrderFeedItem(long OrderId, DateTimeOffset CreatedAtUtc, string Status);

public static async Task<KeysetPage<OrderFeedItem>> LoadOrderPageAsync(
    AppDbContext db,
    OrderCursor? cursor,
    int pageSize,
    CancellationToken cancellationToken)
{
    pageSize = Math.Clamp(pageSize, 1, 100);

    IQueryable<Order> query = db.Orders
        .AsNoTracking()
        .Where(order => !order.IsDeleted);

    if (cursor is not null)
    {
        query = query.Where(order =>
            order.CreatedAtUtc < cursor.CreatedAtUtc ||
            (order.CreatedAtUtc == cursor.CreatedAtUtc && order.Id < cursor.OrderId));
    }

    var rows = await query
        .OrderByDescending(order => order.CreatedAtUtc)
        .ThenByDescending(order => order.Id)
        .Select(order => new OrderFeedItem(
            order.Id,
            order.CreatedAtUtc,
            order.Status))
        .Take(pageSize + 1)
        .ToListAsync(cancellationToken);

    var hasMore = rows.Count > pageSize;
    var items = rows.Take(pageSize).ToList();
    var last = items.LastOrDefault();
    var next = hasMore && last is not null
        ? new OrderCursor(last.CreatedAtUtc, last.OrderId)
        : null;

    return new KeysetPage<OrderFeedItem>(items, next);
}

With an index such as (IsDeleted, CreatedAtUtc DESC, Id DESC) adapted to the provider and filter selectivity, the database seeks from the cursor and reads one page plus one row. The exercise uses a long id so the comparison is valid C# and translates directly. If a real model uses GUID ids, introduce a stable ordered tie-breaker or verify the provider-specific comparison with a relational integration test.

• Many rows share the cursor timestamp.
• The final page has exactly or fewer than pageSize rows.
• A row is inserted or deleted between requests.
• A cursor is reused with different filters.

• Walk all pages through a timestamp tie larger than one page.
• Assert no duplicate ids across pages.
• Insert a newer row between requests.
• Verify hasMore without issuing a count query.

• Using only the timestamp as the cursor.
• Applying Skip and still calling the result keyset pagination.
• Reversing one cursor comparison.
• Returning a next cursor when no extra row exists.