hanna/fabrica

feat(web): paginate the remaining unbounded list views

d578a14 · hanna committed on 2026-07-26

Add a page_slice helper and wire pagination (reusing pagination_nav)
through the lists that fetched everything:

- Explore repos and Explore users
- Profile tabs: Repositories, Bookmarks, Followers, Following
- Branches and Tags
- Long issue/PR comment threads (the pager only appears past one page)
- Admin sign-up invites (admin pager)

The dashboard sidebar is capped with a "View all N repositories" link to
the paginated profile tab, since its `?page` already drives the activity
feed. Issue/PR lists and commits were already paginated.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Signed by hannaSSH key fingerprint: SHA256:4g9cWhkAAw8gwqhJUcVbSnGEvdGwklW+1Aa/fMUu59k

assets/base.css +5 −0

crates/web/src/admin.rs +10 −1

crates/web/src/issues.rs +8 −2

crates/web/src/pages.rs +28 −6

crates/web/src/pulls.rs +6 −0

crates/web/src/repo.rs +51 −6

 .user-ref {
   font-weight: 600;
+}
+/* "View all N repositories" link under the dashboard sidebar list. */
+.dashboard-viewall {
+  margin: 0.6rem 0 0;
+  font-size: 0.9em;
+}
 /* Notifications inbox. */
 .notif-head {
   display: flex;

     RequireAdmin(user): RequireAdmin,
     jar: CookieJar,
     uri: Uri,
+    Query(pager): Query<Pager>,
 ) -> AppResult<Response> {
     // Invites only matter when self-registration is closed; otherwise the page
     // is hidden and its route redirects to the overview.
     if state.allow_registration() {
         return Ok(Redirect::to("/admin").into_response());
+    }
-    let invites = state.store.list_signup_invites().await?;
+    let (page, offset) = pager.resolve();
+    let all = state.store.list_signup_invites().await?;
+    let total = i64::try_from(all.len()).unwrap_or(i64::MAX);
+    let invites: Vec<_> = all
+        .into_iter()
+        .skip(usize::try_from(offset).unwrap_or(0))
+        .take(usize::try_from(PAGE_SIZE).unwrap_or(20))
+        .collect();
     let base = state.config.instance.url.trim_end_matches('/').to_string();
     let (_, chrome) = build_chrome(
         &state,
+                        }
+                    }
+                }
+                (pager_nav("/admin/invites", page, total))
                 form method="post" action="/admin/invites" {
                     input type="hidden" name="_csrf" value=(csrf);
                     div class="admin-form-row admin-form-row-last" {

     let viewer_id: Option<String> = viewer.as_ref().map(|u| u.id.clone());
     let branches = crate::repo::branch_names(state, &ctx.repo.id).await;
-    let mut comment_rows = Vec::with_capacity(comments.len());
+    // Paginate long threads (the pager only appears past one page).
-    for c in &comments {
+    let paging = crate::repo::Pagination::from_query(uri.query());
+    let (page_comments, comments_next) = crate::repo::page_slice(&comments, paging);
+    let mut comment_rows = Vec::with_capacity(page_comments.len());
+    for c in &page_comments {
         comment_rows.push((c, username(state, &c.author_id).await));
+    }
                         (comment_card(cauthor, &base, &c.body, c.created_at,
                             editable.then_some((action.as_str(), csrf.as_str()))))
+                    }
+                    @if comments_next || paging.page > 1 {
+                        (crate::repo::pagination_nav(uri.path(), uri.query(), paging, comments_next))
+                    }
                     @if issue.locked() { (locked_note(can_write)) }
                     @if can_write || (is_author && !issue.locked()) {
                         (comment_box(&issue, &csrf, can_write))

         let body = dashboard_body(&state, &u, &lq.q.unwrap_or_default(), &uri).await?;
         Ok((jar, page(&chrome, "Dashboard", body)).into_response())
     } else {
-        let body = explore_repos_body(&state, "").await?;
+        let body = explore_repos_body(&state, "", &uri).await?;
         Ok((jar, page(&chrome, "Explore", body)).into_response())
+    }
+}
     axum::extract::Query(lq): axum::extract::Query<repo::ListQuery>,
 ) -> AppResult<Response> {
     let (jar, chrome) = build_chrome(&state, jar, user, uri.path().to_string());
-    let body = explore_repos_body(&state, &lq.q.unwrap_or_default()).await?;
+    let body = explore_repos_body(&state, &lq.q.unwrap_or_default(), &uri).await?;
     Ok((jar, page(&chrome, "Explore", body)).into_response())
+}
     axum::extract::Query(lq): axum::extract::Query<repo::ListQuery>,
 ) -> AppResult<Response> {
     let (jar, chrome) = build_chrome(&state, jar, user, uri.path().to_string());
-    let body = explore_users_body(&state, &lq.q.unwrap_or_default()).await?;
+    let body = explore_users_body(&state, &lq.q.unwrap_or_default(), &uri).await?;
     Ok((jar, page(&chrome, "Explore", body)).into_response())
+}
+}
 /// The Explore repositories tab: sub-nav, a search box, and the public repos.
-async fn explore_repos_body(state: &AppState, q: &str) -> AppResult<Markup> {
+async fn explore_repos_body(state: &AppState, q: &str, uri: &Uri) -> AppResult<Markup> {
     let needle = q.trim().to_lowercase();
     let all = state.store.list_repos().await?;
     let public: Vec<_> = all
                 .then(|| RepoEntry::global(owner, r))
         })
         .collect();
+    let paging = repo::Pagination::from_query(uri.query());
+    let (entries, has_next) = repo::page_slice(&entries, paging);
     Ok(html! {
         (explore_subnav("repos"))
         form class="search-row" method="get" action="/explore" {
             button class="btn btn-primary" type="submit" { "Search" }
+        }
         (repo_card("", "No public repositories.", &entries))
+        @if has_next || paging.page > 1 {
+            (repo::pagination_nav(uri.path(), uri.query(), paging, has_next))
+        }
     })
+}
 /// The Explore users tab: sub-nav, a search box, and the user directory.
-async fn explore_users_body(state: &AppState, q: &str) -> AppResult<Markup> {
+async fn explore_users_body(state: &AppState, q: &str, uri: &Uri) -> AppResult<Markup> {
     let needle = q.trim().to_lowercase();
     let users: Vec<User> = state
         .store
                     .is_some_and(|d| d.to_lowercase().contains(&needle))
         })
         .collect();
+    let paging = repo::Pagination::from_query(uri.query());
+    let (users, has_next) = repo::page_slice(&users, paging);
     Ok(html! {
         (explore_subnav("users"))
         form class="search-row" method="get" action="/explore/users" {
             button class="btn btn-primary" type="submit" { "Search" }
+        }
         (user_card(&users))
+        @if has_next || paging.page > 1 {
+            (repo::pagination_nav(uri.path(), uri.query(), paging, has_next))
+        }
     })
+}
 /// The dashboard: the viewer's contribution activity and recent commits, beside
 /// a filterable list of their repositories.
 async fn dashboard_body(state: &AppState, user: &User, q: &str, uri: &Uri) -> AppResult<Markup> {
+    // The sidebar shows a capped slice (the dashboard's `?page` drives the
+    // activity feed); "View all" leads to the paginated profile repos tab.
+    const SIDEBAR_REPOS: usize = 12;
     let now = now_ms();
     let activity = crate::activity::compute(state, user, now).await?;
     let paging = repo::Pagination::from_query(uri.query());
         .filter(|r| needle.is_empty() || r.path.to_lowercase().contains(&needle))
         .map(|r| RepoEntry::owned(&user.username, r))
         .collect();
+    let total = entries.len();
+    let shown: Vec<RepoEntry> = entries.into_iter().take(SIDEBAR_REPOS).collect();
     Ok(html! {
         div class="dashboard" {
                           placeholder="Search repositories…" aria-label="Search repositories";
                     button class="btn btn-primary" type="submit" { "Search" }
+                }
-                (repo_card("Repositories", "You have no repositories yet.", &entries))
+                (repo_card("Repositories", "You have no repositories yet.", &shown))
+                @if total > SIDEBAR_REPOS {
+                    p class="dashboard-viewall" {
+                        a href={ "/" (user.username) "?tab=repos" } {
+                            "View all " (total) " repositories →"
+                        }
+                    }
+                }
+            }
+        }
     })

     let (jar, chrome) = build_chrome(state, jar, viewer, uri.path().to_string());
     let csrf = chrome.csrf.clone();
     let repo_base = format!("/{}/{}", ctx.owner.username, ctx.repo.path);
+    // Paginate long comment threads (the pager only shows past one page).
+    let paging = crate::repo::Pagination::from_query(uri.query());
+    let (comment_rows, comments_next) = crate::repo::page_slice(&comment_rows, paging);
     let body = html! {
         (repo_header(state, &ctx, Tab::Pulls, &ctx.repo.default_branch, &branches))
         div class="issue-view" {
                         (comment_card(cauthor, &repo_base, &c.body, c.created_at,
                             editable.then_some((action.as_str(), csrf.as_str()))))
+                    }
+                    @if comments_next || paging.page > 1 {
+                        (crate::repo::pagination_nav(uri.path(), uri.query(), paging, comments_next))
+                    }
                     (merge_panel(&issue, &pr, mergeable, blocked, &csrf))
                     @if issue.locked() { (locked_note(can_write)) }
                     @if can_write || (is_author && !issue.locked()) {

+    }
+}
+/// Slice an already-fetched list to the current page, returning the page's items
+/// and whether a next page exists. For lists that are filtered/searched in Rust
+/// (so SQL `LIMIT`/`OFFSET` cannot bound them), this keeps the rendered output
+/// bounded even when the full set is large.
+pub(crate) fn page_slice<T: Clone>(items: &[T], p: Pagination) -> (Vec<T>, bool) {
+    let start = p.offset().min(items.len());
+    let end = start.saturating_add(p.per_page).min(items.len());
+    let has_next = end < items.len();
+    (items[start..end].to_vec(), has_next)
+}
 /// Render prev/next controls and a page-size selector for a paginated list.
 ///
 /// `path` is the list URL and `query` its current query string; every query
     let q = lq.q.unwrap_or_default();
     let needle = q.trim().to_lowercase();
     let base = format!("/{}", owner.username);
+    let paging = Pagination::from_query(uri.query());
     let content = match tab {
         ProfileTab::Repos => {
                 })
                 .map(|r| RepoEntry::owned(&owner.username, r))
                 .collect();
+            let (entries, has_next) = page_slice(&entries, paging);
             html! {
                 form class="search-row" method="get" {
                     input type="search" name="q" value=(q)
                     button class="btn btn-primary" type="submit" { "Search" }
+                }
                 (repo_card("", "No repositories.", &entries))
+                @if has_next || paging.page > 1 {
+                    (pagination_nav(uri.path(), uri.query(), paging, has_next))
+                }
+            }
+        }
         ProfileTab::Groups => {
                 .collect();
             // Replace the owner-id label with the username where we can.
             let entries = resolve_bookmark_labels(&state, &visible, entries).await;
-            html! { (repo_card("", "No bookmarks yet.", &entries)) }
+            let (entries, has_next) = page_slice(&entries, paging);
+            html! {
+                (repo_card("", "No bookmarks yet.", &entries))
+                @if has_next || paging.page > 1 {
+                    (pagination_nav(uri.path(), uri.query(), paging, has_next))
+                }
+            }
+        }
         ProfileTab::Followers => {
             let users = state.store.followers(&owner.id).await?;
-            user_list(&state, &users, viewer.as_ref(), "No followers yet.").await?
+            let (page, has_next) = page_slice(&users, paging);
+            html! {
+                (user_list(&state, &page, viewer.as_ref(), "No followers yet.").await?)
+                @if has_next || paging.page > 1 {
+                    (pagination_nav(uri.path(), uri.query(), paging, has_next))
+                }
+            }
+        }
         ProfileTab::Following => {
             let users = state.store.following(&owner.id).await?;
-            user_list(&state, &users, viewer.as_ref(), "Not following anyone yet.").await?
+            let (page, has_next) = page_slice(&users, paging);
+            html! {
+                (user_list(&state, &page, viewer.as_ref(), "Not following anyone yet.").await?)
+                @if has_next || paging.page > 1 {
+                    (pagination_nav(uri.path(), uri.query(), paging, has_next))
+                }
+            }
+        }
     };
     uri: &Uri,
     ctx: RepoCtx,
 ) -> AppResult<Response> {
-    let branches = git_read(state, &ctx.repo.id, git::Repo::branches).await?;
+    let all = git_read(state, &ctx.repo.id, git::Repo::branches).await?;
-    let branch_list: Vec<String> = branches.iter().map(|b| b.name.clone()).collect();
+    let branch_list: Vec<String> = all.iter().map(|b| b.name.clone()).collect();
     let base = format!("/{}/{}", ctx.owner.username, ctx.repo.path);
     let now = crate::now_ms();
+    let paging = Pagination::from_query(uri.query());
+    let (branches, has_next) = page_slice(&all, paging);
     let body = html! {
         (repo_header(state, &ctx, Tab::Branches, &ctx.repo.default_branch, &branch_list))
         ul class="entry-list card" {
+                }
+            }
+        }
+        @if has_next || paging.page > 1 {
+            (pagination_nav(uri.path(), uri.query(), paging, has_next))
+        }
     };
     let (jar, chrome) = build_chrome(state, jar, viewer, uri.path().to_string());
     let title = format!("{}/{}: branches", ctx.owner.username, ctx.repo.path);
     uri: &Uri,
     ctx: RepoCtx,
 ) -> AppResult<Response> {
-    let tags = git_read(state, &ctx.repo.id, git::Repo::tags).await?;
+    let all = git_read(state, &ctx.repo.id, git::Repo::tags).await?;
     let branches = branch_names(state, &ctx.repo.id).await;
     let base = format!("/{}/{}", ctx.owner.username, ctx.repo.path);
+    let paging = Pagination::from_query(uri.query());
+    let (tags, has_next) = page_slice(&all, paging);
     let body = html! {
         (repo_header(state, &ctx, Tab::Tags, &ctx.repo.default_branch, &branches))
         @if tags.is_empty() {
+                    }
+                }
+            }
+            @if has_next || paging.page > 1 {
+                (pagination_nav(uri.path(), uri.query(), paging, has_next))
+            }
+        }
     };
     let (jar, chrome) = build_chrome(state, jar, viewer, uri.path().to_string());
+}
 /// One row in a repository listing card.
+#[derive(Clone)]
 pub(crate) struct RepoEntry {
     /// Link target.
     pub(crate) href: String,