hanna/fabrica

feat(web): paginate admin lists and tidy admin forms

604537e · hanna committed on 2026-07-26

- Users, Repositories, and Groups lists paginate at 20 rows (?page=N),
  using new store methods list_{users,repos,groups}_paged and the
  existing admin_counts totals for the page count.
- Create-a-user: move the password hint above a bottom row that pairs
  the Administrator checkbox with the Create button.
- Reset-a-password and Create-invite: the submit button now sits inline
  to the right of its input.
- Instance settings: wrap each label+control in a .form-field for even
  vertical rhythm, with the toggles and Save button in a bottom row.

The password picker still lists every account (not just the visible
page) so any user can be reset.

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

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

assets/base.css +22 −0

crates/store/src/groups.rs +24 −0

crates/store/src/repos.rs +20 −0

crates/store/src/tests.rs +32 −0

crates/store/src/users.rs +20 −0

crates/web/src/admin.rs +89 −24

   flex: 1;
   min-width: 9rem;
+}
+/* A control row that is the last thing in its form carries no trailing gap. */
+.admin-form-row-last {
+  margin-bottom: 0;
+}
+/* A bottom row pairing option toggles/checkboxes with the submit button. */
+.admin-form-actions {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 0.75rem;
+  margin-top: 0.5rem;
+}
+.admin-form-actions label.checkbox {
+  margin: 0;
+}
+/* Stacked label + control groups (admin settings). */
+.form-field {
+  margin-bottom: 0.9rem;
+}
+.form-field label {
+  margin-top: 0;
+}
 /* Settings: a left tab rail and the active tab's content. */
 .settings-layout {

             .map_err(Into::into)
+    }
+    /// One page of groups, ordered by owner then path. For the admin view.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`StoreError::Query`] on a database failure.
+    pub async fn list_groups_paged(
+        &self,
+        limit: i64,
+        offset: i64,
+    ) -> Result<Vec<Group>, StoreError> {
+        let sql = format!(
+            "SELECT {GROUP_COLUMNS} FROM groups ORDER BY owner_id ASC, path ASC LIMIT $1 OFFSET $2"
+        );
+        let rows = sqlx::query(AssertSqlSafe(sql))
+            .bind(limit)
+            .bind(offset)
+            .fetch_all(&self.pool)
+            .await?;
+        rows.iter()
+            .map(map_group)
+            .collect::<Result<_, _>>()
+            .map_err(Into::into)
+    }
     /// Delete a group by id. Child groups cascade (`ON DELETE CASCADE`); repos in
     /// the group have their `group_id` set null by the schema, so they survive as
     /// ungrouped repos. Returns `true` if a row was deleted.

             .map_err(Into::into)
+    }
+    /// One page of repositories, ordered by owner then path. For the admin view.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`StoreError::Query`] on a database failure.
+    pub async fn list_repos_paged(&self, limit: i64, offset: i64) -> Result<Vec<Repo>, StoreError> {
+        let sql = format!(
+            "SELECT {REPO_COLUMNS} FROM repos ORDER BY owner_id ASC, path ASC LIMIT $1 OFFSET $2"
+        );
+        let rows = sqlx::query(AssertSqlSafe(sql))
+            .bind(limit)
+            .bind(offset)
+            .fetch_all(&self.pool)
+            .await?;
+        rows.iter()
+            .map(|r| self.map_repo(r))
+            .collect::<Result<_, _>>()
+            .map_err(Into::into)
+    }
     /// Rename a repository: update its leaf `name` and materialized `path`
     /// (metadata only — the on-disk directory is keyed by id and never moves).
     ///

+}
 #[tokio::test]
+async fn list_users_paged_slices_by_limit_and_offset() {
+    for fx in sqlite_fixtures().await {
+        for name in ["alice", "Bob", "Charlie", "dave"] {
+            fx.store
+                .create_user(sample_user(name, &format!("{name}@example.com")))
+                .await
+                .unwrap();
+        }
+        let page1: Vec<String> = fx
+            .store
+            .list_users_paged(2, 0)
+            .await
+            .unwrap()
+            .into_iter()
+            .map(|u| u.username)
+            .collect();
+        assert_eq!(page1, ["alice", "Bob"]);
+        let page2: Vec<String> = fx
+            .store
+            .list_users_paged(2, 2)
+            .await
+            .unwrap()
+            .into_iter()
+            .map(|u| u.username)
+            .collect();
+        assert_eq!(page2, ["Charlie", "dave"]);
+        // Past the end yields nothing.
+        assert!(fx.store.list_users_paged(2, 4).await.unwrap().is_empty());
+    }
+}
+#[tokio::test]
 async fn delete_user_cascades_to_repos() {
     for fx in sqlite_fixtures().await {
         let user = fx

             .map_err(Into::into)
+    }
+    /// One page of users, ordered case-insensitively by username.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`StoreError::Query`] on a database failure.
+    pub async fn list_users_paged(&self, limit: i64, offset: i64) -> Result<Vec<User>, StoreError> {
+        let sql = format!(
+            "SELECT {USER_COLUMNS} FROM users ORDER BY username_lower ASC LIMIT $1 OFFSET $2"
+        );
+        let rows = sqlx::query(AssertSqlSafe(sql))
+            .bind(limit)
+            .bind(offset)
+            .fetch_all(&self.pool)
+            .await?;
+        rows.iter()
+            .map(|r| self.map_user(r))
+            .collect::<Result<_, _>>()
+            .map_err(Into::into)
+    }
     /// Change a user's username (case-preserved, case-insensitively unique).
     ///
     /// # Errors

 use std::path::{Path as FsPath, PathBuf};
 use axum::Form;
-use axum::extract::{Path, State};
+use axum::extract::{Path, Query, State};
 use axum::http::{HeaderMap, Uri};
 use axum::response::{IntoResponse, Redirect, Response};
 use axum_extra::extract::cookie::CookieJar;
     (jar, page(&chrome, "Admin", admin_shell(active, content))).into_response()
+}
+/// Rows shown per page in the admin list views.
+const PAGE_SIZE: i64 = 20;
+/// The `?page=N` (1-based) query parameter shared by the paginated lists.
+#[derive(Debug, Default, Deserialize)]
+pub struct Pager {
+    #[serde(default)]
+    page: Option<i64>,
+}
+impl Pager {
+    /// The clamped 1-based page number and its row offset.
+    fn resolve(&self) -> (i64, i64) {
+        let page = self.page.unwrap_or(1).max(1);
+        (page, (page - 1) * PAGE_SIZE)
+    }
+}
+/// Previous/next controls under a list, shown only when `total` spans more than
+/// one page. `base` is the list path (e.g. `/admin/users`).
+fn pager_nav(base: &str, page: i64, total: i64) -> Markup {
+    let pages = ((total + PAGE_SIZE - 1) / PAGE_SIZE).max(1);
+    html! {
+        @if pages > 1 {
+            nav class="pagination" aria-label="Pagination" {
+                @if page > 1 {
+                    a class="btn" href=(format!("{base}?page={}", page - 1)) { "← Previous" }
+                } @else {
+                    span class="btn disabled" aria-disabled="true" { "← Previous" }
+                }
+                span class="muted pagination-page" { "Page " (page) " of " (pages) }
+                @if page < pages {
+                    a class="btn" href=(format!("{base}?page={}", page + 1)) { "Next →" }
+                } @else {
+                    span class="btn disabled" aria-disabled="true" { "Next →" }
+                }
+            }
+        }
+    }
+}
 // ---- Overview ----
 /// `GET /admin` — instance statistics.
     RequireAdmin(user): RequireAdmin,
     jar: CookieJar,
     uri: Uri,
+    Query(pager): Query<Pager>,
 ) -> AppResult<Response> {
-    let all = state.store.list_users().await?;
+    let (page, offset) = pager.resolve();
+    let total = state.store.admin_counts().await?.users;
+    let all = state.store.list_users_paged(PAGE_SIZE, offset).await?;
+    // The password picker offers every account, not just the current page.
+    let everyone = state.store.list_users().await?;
     let (_, chrome) = build_chrome(
         &state,
         jar.clone(),
+                        }
+                    }
+                }
+                (pager_nav("/admin/users", page, total))
+            }
+        }
         section class="listing" {
                         input type="email" name="email" placeholder="email" required;
                         input type="password" name="password" placeholder="password (optional)";
+                    }
-                    label class="checkbox" { input type="checkbox" name="admin" value="1"; " Administrator" }
+                    p class="muted field-hint" { "Leaving the password blank creates an account that must be activated by the user (they'll need an invite/reset)." }
-                    button class="btn btn-primary inline-btn" type="submit" { "Create user" }
+                    div class="admin-form-actions" {
+                        label class="checkbox" { input type="checkbox" name="admin" value="1"; " Administrator" }
+                        button class="btn btn-primary inline-btn" type="submit" { "Create user" }
+                    }
+                }
-                p class="muted field-hint" { "Leaving the password blank creates an account that must be activated by the user (they'll need an invite/reset)." }
+            }
+        }
         section class="listing" {
                     input type="hidden" name="_csrf" value=(csrf);
                     div class="admin-form-row" {
                         select name="user_id" aria-label="User" {
-                            @for u in &all { option value=(u.id) { (u.username) } }
+                            @for u in &everyone { option value=(u.id) { (u.username) } }
+                        }
                         input type="password" name="password" placeholder="new password" required minlength="8";
+                        button class="btn inline-btn" type="submit" { "Set password" }
+                    }
-                    button class="btn inline-btn" type="submit" { "Set password" }
+                }
+            }
+        }
     RequireAdmin(user): RequireAdmin,
     jar: CookieJar,
     uri: Uri,
+    Query(pager): Query<Pager>,
 ) -> AppResult<Response> {
-    let repos = state.store.list_repos().await?;
+    let (page, offset) = pager.resolve();
+    let total = state.store.admin_counts().await?.repos;
+    let repos = state.store.list_repos_paged(PAGE_SIZE, offset).await?;
     // Resolve owner names for links.
     let mut owners = std::collections::HashMap::new();
     for r in &repos {
+                        }
+                    }
+                }
+                (pager_nav("/admin/repos", page, total))
+            }
+        }
     };
     RequireAdmin(user): RequireAdmin,
     jar: CookieJar,
     uri: Uri,
+    Query(pager): Query<Pager>,
 ) -> AppResult<Response> {
-    let groups = state.store.list_groups().await?;
+    let (page, offset) = pager.resolve();
+    let total = state.store.admin_counts().await?.groups;
+    let groups = state.store.list_groups_paged(PAGE_SIZE, offset).await?;
     let mut owners = std::collections::HashMap::new();
     for g in &groups {
         if !owners.contains_key(&g.owner_id)
+                        }
+                    }
+                }
+                (pager_nav("/admin/groups", page, total))
                 p class="muted field-hint" { "Deleting a group ungroups its repositories (they are not deleted)." }
+            }
+        }
+                }
                 form method="post" action="/admin/invites" {
                     input type="hidden" name="_csrf" value=(csrf);
-                    div class="admin-form-row" {
+                    div class="admin-form-row admin-form-row-last" {
                         input type="text" name="note" placeholder="note (optional, e.g. who it's for)";
+                        button class="btn btn-primary inline-btn" type="submit" { "Create invite" }
+                    }
-                    button class="btn btn-primary inline-btn" type="submit" { "Create invite" }
+                }
+            }
+        }
             "These override the config file. Leaving a field at its default keeps the config value; each row can be reset."
+        }
         div class="card" {
-            form method="post" action="/admin/settings" {
+            form method="post" action="/admin/settings" class="stacked-form" {
                 input type="hidden" name="_csrf" value=(csrf);
-                label for="s-name" { "Instance name" }
+                div class="form-field" {
-                input type="text" id="s-name" name="name" value=(name);
+                    label for="s-name" { "Instance name" }
-                label for="s-desc" { "Description" }
+                    input type="text" id="s-name" name="name" value=(name);
-                input type="text" id="s-desc" name="description" value=(desc);
+                }
-                label for="s-vis" { "Default repository visibility" }
+                div class="form-field" {
-                select id="s-vis" name="default_visibility" {
+                    label for="s-desc" { "Description" }
-                    (vis_opt("public", "Public"))
+                    input type="text" id="s-desc" name="description" value=(desc);
-                    (vis_opt("internal", "Internal"))
+                }
-                    (vis_opt("private", "Private"))
+                div class="form-field" {
+                    label for="s-vis" { "Default repository visibility" }
+                    select id="s-vis" name="default_visibility" {
+                        (vis_opt("public", "Public"))
+                        (vis_opt("internal", "Internal"))
+                        (vis_opt("private", "Private"))
+                    }
+                }
+                div class="admin-form-actions" {
+                    label class="checkbox" { input type="checkbox" name="allow_registration" value="1" checked[reg]; " Allow self-registration" }
+                    label class="checkbox" { input type="checkbox" name="allow_anonymous" value="1" checked[anon]; " Allow anonymous browse/clone" }
+                    button class="btn btn-primary inline-btn" type="submit" { "Save settings" }
+                }
-                label class="checkbox" { input type="checkbox" name="allow_registration" value="1" checked[reg]; " Allow self-registration" }
-                label class="checkbox" { input type="checkbox" name="allow_anonymous" value="1" checked[anon]; " Allow anonymous browse/clone" }
-                button class="btn btn-primary inline-btn" type="submit" { "Save settings" }
+            }
+        }
     };