VerticalSlices: Skill for Claude Code

Query Paging

Arc applies paging and sorting automatically to any model-bound query that returns IQueryable<T>. The HTTP layer reads ?page=, ?pageSize=, ?sortby=, ?sortDirection= and applies them before the query materializes — you don't write skip/take/sort. If a result set is small and bounded, IEnumerable<T> is fine and you don't need this.

Steps

1. One-shot paged query — IQueryable<T>

[ReadModel]
public record Project(...)
{
    public static IQueryable<Project> AllProjects(IMongoCollection<Project> collection) =>
        collection.AsQueryable();

    // Filtered — apply the predicate before returning; Arc pages on top of it:
    public static IQueryable<Project> ActiveProjects(IMongoCollection<Project> collection) =>
        collection.AsQueryable().Where(p => !p.IsArchived);

    // Sensible default order when the caller passes no sortby:
    public static IQueryable<Project> AllByName(IMongoCollection<Project> collection) =>
        collection.AsQueryable().OrderBy(p => p.Name);
}

2. Observable + paged — ISubject<IEnumerable<T>>

For live updates and paging, return what Observe returns:

public static ISubject<IEnumerable<Project>> AllProjectsLive(IMongoCollection<Project> collection) =>
    collection.Observe(_ => _.Find(p => !p.IsArchived));

Each emission carries page metadata alongside the data. Sorting and paging are applied at the source and re-applied on every change — the storage Observe helpers read the ambient query context themselves rather than going through the query renderer.

⚠️ Do not wrap it as ISubject<IQueryable<T>>. No Observe overload returns that shape, and the renderer matches on the outer type, so nothing would page it.

3. What does and doesn't page

Return type	Paging?	How
T, T?, IEnumerable<T>, List<T>, T[]	No	Nothing narrows the result
IQueryable<T>	Yes — auto-paged	The query renderer applies OrderBy/Skip/Take to the queryable
Task<IQueryable<T>>	Yes — auto-paged	The result is awaited first, then rendered as the queryable it unwraps to
ISubject<IEnumerable<T>>	Yes — paged and sorted	Not by the renderer. The storage Observe() helpers read the ambient query context themselves and apply sorting and paging at the source, re-applying them on every change
ISubject<IQueryable<T>>	No — not a shipped shape	No Observe overload returns it, and the renderer matches on the outer type, so it never fires