@podosoft/podokit 1.1.6 → 1.3.0

package/dist/templates/modules/admin-dashboard/files/apps/web/src/routes/(admin)/admin/users/+page.svelte

@@ -1,4 +1,5 @@
 <script lang="ts">
+  import { untrack } from "svelte";
   import { goto } from "$app/navigation";
   import { Button } from "#lib/components/ui/button/index.js";
   import { Input } from "#lib/components/ui/input/index.js";
@@ -15,6 +16,8 @@
   import PlusIcon from "@lucide/svelte/icons/plus";
   import { toast } from "svelte-sonner";
   import { api } from "#lib/api.js";
+  import { listAdminSessions, revokeAdminSession, type AdminSession } from "#lib/admin/sessions.js";
+  import { DEFAULT_USER_SORT, adminUsersQuery, listAdminUsers } from "#lib/admin/users.js";
   import { getI18n, fmt, formatDateTime } from "#lib/i18n/index.js";
   import { cn } from "#lib/utils.js";
   import { deviceLabel } from "#lib/device-label.js";
@@ -42,11 +45,16 @@
   };
 
   const PAGE_SIZE = DEFAULT_PAGE_SIZE;
-  const LOAD_LIMIT = 500; // bounded client-side list; add server-side filtering for larger deployments
+  // Sessions shown in the manage dialog: the newest page for one user.
+  const MANAGED_SESSIONS_LIMIT = 100;
   let users = $state<Row[]>([]);
+  let total = $state(0);
   let page = $state(1);
-  let sort = $state<SortState | null>(null);
+  let sort = $state<SortState | null>({ ...DEFAULT_USER_SORT });
+  let loading = $state(false);
   let busy = $state(false);
+  let latestRequest = 0;
+  let loadedSortKey = `${DEFAULT_USER_SORT.key}:${DEFAULT_USER_SORT.dir}`;
 
   // Toolbar: filters + search both commit on the Search button (nothing applies
   // until then), so multiple filter/search conditions apply together.
@@ -93,32 +101,50 @@
     { value: "name", label: i18n.t.users.name },
   ]);
 
-  const filtered = $derived(
-    users.filter((u) => {
-      if (appliedSearch) {
-        const hay = (appliedSearchField === "name" ? u.name : u.email).toLowerCase();
-        if (!hay.includes(appliedSearch.toLowerCase())) return false;
-      }
-      if (appliedFilters.role && (u.role ?? "user") !== appliedFilters.role) return false;
-      if (appliedFilters.status === "banned" && !u.banned) return false;
-      if (appliedFilters.status === "pending" && u.signupApproved !== false) return false;
-      if (appliedFilters.status === "active" && (u.banned || u.signupApproved === false)) return false;
-      return true;
-    }),
-  );
-
+  // Loads only the current page; a newer request supersedes one still in flight.
   async function load(): Promise<void> {
-    const { data: res, error } = await api.auth.admin.listUsers({ query: { limit: LOAD_LIMIT } });
-    if (error) return void toast.error(error.message ?? i18n.t.users.loadFailed);
-    users = (res?.users ?? []) as Row[];
+    const request = ++latestRequest;
+    const sortKey = sort ? `${sort.key}:${sort.dir}` : "";
+    if (sortKey !== loadedSortKey) page = 1;
+    const query = adminUsersQuery({
+      page,
+      perPage: PAGE_SIZE,
+      sort,
+      search: appliedSearch,
+      searchField: appliedSearchField,
+      role: appliedFilters.role ?? "",
+      status: appliedFilters.status ?? "",
+    });
+    loading = true;
+    let result: { items: Row[]; total: number };
+    try {
+      result = await listAdminUsers(api, query);
+    } catch {
+      if (request !== latestRequest) return;
+      loading = false;
+      return void toast.error(i18n.t.users.loadFailed);
+    }
+    if (request !== latestRequest) return;
+    loading = false;
+    const rows = result.items;
+    const count = result.total;
+    // An action can empty the last page; show the one before it instead.
+    const lastPage = Math.max(Math.ceil(count / PAGE_SIZE), 1);
+    if (rows.length === 0 && page > lastPage) {
+      page = lastPage;
+      return load();
+    }
+    loadedSortKey = sortKey;
+    users = rows;
+    total = count;
   }
 
-  async function applySearch(): Promise<void> {
-    await load(); // refresh from the server on explicit search, then filter client-side
+  function applySearch(): void {
     appliedSearch = search;
     appliedSearchField = searchField;
     appliedFilters = { ...filterValues };
     page = 1;
+    void load();
   }
 
   // Impersonate — become the user, then continue on the signed-in account page
@@ -176,7 +202,6 @@
 
   // Manage user — a two-pane modal mirroring the account settings, admin-scoped.
   type ManageSection = "profile" | "security" | "sessions" | "danger";
-  type Session = { id: string; token: string; userAgent?: string | null; ipAddress?: string | null; createdAt: string | Date };
   let manageOpen = $state(false);
   let mUser = $state<Row | null>(null);
   let mSection = $state<ManageSection>("profile");
@@ -192,10 +217,11 @@
   let mBanReason = $state("");
   let mBanDays = $state("");
   // sessions
-  let mSessions = $state<Session[]>([]);
+  let mSessions = $state<AdminSession[]>([]);
+  let mSessionsTotal = $state(0);
   let mSessionsPage = $state(1);
   let mSessionsSort = $state<SortState | null>(null);
-  const mSessionsColumns: DataTableColumn<Session>[] = [
+  const mSessionsColumns: DataTableColumn<AdminSession>[] = [
     { key: "userAgent", label: i18n.t.adminSessions.device, sortable: true, value: (s) => deviceLabel(s.userAgent) ?? s.userAgent ?? "" },
     { key: "ipAddress", label: i18n.t.adminSessions.ip, sortable: true },
     { key: "createdAt", label: i18n.t.adminSessions.since, sortable: true, value: (s) => new Date(s.createdAt).getTime() },
@@ -217,6 +243,7 @@
     mBanDays = "";
     mDeleteArmed = false;
     mSessions = [];
+    mSessionsTotal = 0;
     mSessionsPage = 1;
     manageOpen = true;
     await loadManagedSessions();
@@ -224,8 +251,15 @@
 
   async function loadManagedSessions(): Promise<void> {
     if (!mUser) return;
-    const { data: res } = await api.auth.admin.listUserSessions({ userId: mUser.id });
-    mSessions = (res?.sessions ?? []) as Session[];
+    const userId = mUser.id;
+    try {
+      const result = await listAdminSessions(api, { limit: MANAGED_SESSIONS_LIMIT, userId });
+      if (mUser?.id !== userId) return;
+      mSessions = result.items;
+      mSessionsTotal = result.total;
+    } catch {
+      toast.error(i18n.t.adminSessions.loadFailed);
+    }
   }
 
   async function saveProfile(event: Event): Promise<void> {
@@ -329,11 +363,15 @@
     await load();
   }
 
-  async function revokeSession(token: string): Promise<void> {
+  async function revokeSession(id: string): Promise<void> {
     busy = true;
-    const { error } = await api.auth.admin.revokeUserSession({ sessionToken: token });
-    busy = false;
-    if (error) return void toast.error(error.message ?? i18n.t.adminSessions.loadFailed);
+    try {
+      await revokeAdminSession(api, id);
+    } catch {
+      return void toast.error(i18n.t.adminSessions.revokeFailed);
+    } finally {
+      busy = false;
+    }
     toast.success(i18n.t.adminSessions.revoked);
     await loadManagedSessions();
   }
@@ -343,7 +381,7 @@
     busy = true;
     const { error } = await api.auth.admin.revokeUserSessions({ userId: mUser.id });
     busy = false;
-    if (error) return void toast.error(error.message ?? i18n.t.adminSessions.loadFailed);
+    if (error) return void toast.error(error.message ?? i18n.t.adminSessions.revokeFailed);
     toast.success(i18n.t.adminSessions.allRevoked);
     await loadManagedSessions();
   }
@@ -360,7 +398,7 @@
   }
 
   $effect(() => {
-    void load();
+    untrack(() => void load());
   });
 </script>
 
@@ -383,14 +421,18 @@
 
   <DataTable
     {columns}
-    rows={filtered}
+    rows={users}
     getKey={(u) => u.id}
-    empty={i18n.t.users.empty}
+    empty={loading ? "…" : i18n.t.users.empty}
     bind:sort
     bind:page
+    manualSort
+    manualPagination
     perPage={PAGE_SIZE}
+    {total}
     ariaLabel={i18n.t.users.title}
-    label={fmt(i18n.t.users.total, { count: filtered.length })}
+    label={fmt(i18n.t.users.total, { count: total })}
+    onChange={() => void load()}
   >
     {#snippet row(user, { cellClass })}
       <Table.Cell class={cn(cellClass("name"), "font-medium")}>{user.name}</Table.Cell>
@@ -555,14 +597,14 @@
               bind:sort={mSessionsSort}
               bind:page={mSessionsPage}
               perPage={PAGE_SIZE}
-              label={fmt(i18n.t.adminSessions.total, { count: mSessions.length })}
+              label={fmt(i18n.t.adminSessions.total, { count: mSessionsTotal })}
               empty={i18n.t.adminSessions.empty}
             >
               {#snippet row(s)}
                 <Table.Cell class="max-w-40 truncate" title={s.userAgent ?? ""}>{deviceLabel(s.userAgent) ?? s.userAgent ?? i18n.t.adminSessions.unknown}</Table.Cell>
                 <Table.Cell class="text-muted-foreground">{s.ipAddress ?? "—"}</Table.Cell>
                 <Table.Cell class="text-muted-foreground">{formatDateTime(s.createdAt)}</Table.Cell>
-                <Table.Cell><Button variant="ghost" size="sm" disabled={busy} onclick={() => revokeSession(s.token)}>{i18n.t.users.revokeSession}</Button></Table.Cell>
+                <Table.Cell><Button variant="ghost" size="sm" disabled={busy} onclick={() => revokeSession(s.id)}>{i18n.t.users.revokeSession}</Button></Table.Cell>
               {/snippet}
             </DataTable>
           </div>

package/dist/templates/modules/admin-dashboard/files/apps/web/src/routes/+layout.server.ts

@@ -1,9 +1,8 @@
 import type { LayoutServerLoad } from "./$types";
 import { redirect } from "@sveltejs/kit";
 import { safeAuthRedirect } from "#lib/auth-redirect.js";
-import { loadMessages } from "#lib/i18n/messages.js";
+import { getCapabilities } from "#lib/server/capabilities.js";
 import { isPublicPath, requireBackendAvailable } from "#lib/server/guards.js";
-import type { Capabilities } from "@podosoft/podokit-api-client";
 
 // "/" is a public landing page. Auth pages return signed-in users to their safe
 // requested page, and the admin area requires a session. /maintenance is public
@@ -43,19 +42,13 @@ export const load: LayoutServerLoad = async (event) => {
   if (!locals.user && !isPublicPath(pathname)) {
     redirect(303, `/login?redirect=${encodeURIComponent(`${pathname}${url.search}`)}`);
   }
-  let sessionIdleTimeoutMinutes: number | null = null;
-  if (locals.user) {
-    try {
-      const response = await event.fetch("/api/account/capabilities");
-      if (response.ok) {
-        const capabilities = (await response.json()) as Capabilities;
-        sessionIdleTimeoutMinutes = capabilities.sessionIdleTimeoutMinutes ?? null;
-      }
-    } catch {
-      // Keep automatic logout disabled in the browser if policy lookup fails.
-      // The server-side session expiration remains authoritative.
-    }
-  }
-  const messages = await loadMessages(locals.locale, site?.locale);
-  return { user: locals.user, locale: locals.locale, messages, site, sessionIdleTimeoutMinutes };
+  // Automatic logout stays disabled in the browser if the policy lookup fails;
+  // the server-side session expiration remains authoritative. Protected loads
+  // of the same request reuse this capabilities response.
+  const sessionIdleTimeoutMinutes = locals.user
+    ? ((await getCapabilities(event)).sessionIdleTimeoutMinutes ?? null)
+    : null;
+  // Messages are resolved by the universal +layout.ts. This load re-runs on every
+  // client navigation for the path checks above and must not resend them.
+  return { user: locals.user, locale: locals.locale, site, sessionIdleTimeoutMinutes };
 };

package/dist/templates/modules/admin-dashboard/files/apps/web/src/routes/+layout.ts

@@ -0,0 +1,10 @@
+import { loadMessages } from "#lib/i18n/messages.js";
+import type { LayoutLoad } from "./$types";
+
+// Runs on the server for the first render and in the browser afterwards, so the
+// catalogs never travel in `__data.json`. loadMessages() reuses one merged
+// object per locale pair; the language switch changes `data.locale`.
+export const load: LayoutLoad = async ({ data }) => ({
+  ...data,
+  messages: await loadMessages(data.locale, data.site?.locale),
+});

package/dist/templates/modules/admin-dashboard/files/apps/web/src/routes/oauth2/consent/+page.svelte

@@ -3,6 +3,7 @@
   import { Button } from "#lib/components/ui/button/index.js";
   import * as Card from "#lib/components/ui/card/index.js";
   import { getI18n } from "#lib/i18n/index.js";
+  import { signedOAuthQuery } from "#lib/oauth-query.js";
 
   const i18n = getI18n();
   // The OAuth provider redirects here with the authorization request in the query
@@ -14,13 +15,13 @@
   async function decide(accept: boolean): Promise<void> {
     busy = true;
     // The authorization request is carried in the signed query params we were
-    // redirected here with; forward them verbatim so the server can validate and
-    // restore it. Credentials carry the user's session. The response says where next.
+    // redirected here with; the server verifies them from the body, then restores
+    // the request. Credentials carry the user's session. The response says where next.
     const res = await fetch(`/api/auth/oauth2/consent${page.url.search}`, {
       method: "POST",
       credentials: "include",
       headers: { "content-type": "application/json" },
-      body: JSON.stringify({ accept }),
+      body: JSON.stringify({ accept, oauth_query: signedOAuthQuery(page.url.search) }),
     });
     const data = (await res.json().catch(() => ({}))) as { url?: string; redirectURI?: string };
     const next = data.url ?? data.redirectURI;

package/dist/templates/modules/admin-dashboard/files/apps/web/src/routes/setup-2fa/+page.svelte

@@ -1,6 +1,5 @@
 <script lang="ts">
   import { goto } from "$app/navigation";
-  import QRCode from "qrcode";
   import { Button } from "#lib/components/ui/button/index.js";
   import { Input } from "#lib/components/ui/input/index.js";
   import { Label } from "#lib/components/ui/label/index.js";
@@ -21,13 +20,20 @@
 
   $effect(() => {
     const uri = setup?.totpURI;
-    if (!uri) {
-      qrDataUrl = "";
-      return;
-    }
-    QRCode.toDataURL(uri, { margin: 1, width: 176 })
-      .then((url) => (qrDataUrl = url))
-      .catch(() => (qrDataUrl = ""));
+    qrDataUrl = "";
+    if (!uri) return;
+    let active = true;
+    import("qrcode")
+      .then(({ toDataURL }) => toDataURL(uri, { margin: 1, width: 176 }))
+      .then((url) => {
+        if (active && setup?.totpURI === uri) qrDataUrl = url;
+      })
+      .catch(() => {
+        if (active) qrDataUrl = "";
+      });
+    return () => {
+      active = false;
+    };
   });
 
   async function begin(): Promise<void> {

package/dist/templates/modules/admin-dashboard/files/dot-claude/skills/podokit-data-table/SKILL.md

@@ -44,5 +44,6 @@ put pagination outside the table.
   above the DataTable. Filters + search apply together on the Search button/Enter
   (don't query on every keystroke); the search field is a `select` of columns.
 
-The `/admin/users` page is the reference implementation. See `docs/development.md`
+The `/admin/users` page is the reference implementation (server offset paging);
+`/admin/sessions` shows keyset paging with a cursor. See `docs/development.md`
 ("Data tables", "Search & filters") on the PodoKit repo.

package/dist/templates/modules/admin-dashboard/files/tests/api/admin-sessions.api.spec.ts

@@ -0,0 +1,124 @@
+import type { APIRequestContext, PlaywrightWorkerArgs } from "@playwright/test";
+import { expect, test } from "../helpers/disposable-users";
+import { ADMIN, USER } from "../helpers/accounts";
+
+const base = process.env.E2E_BASE_URL ?? "http://localhost:5001";
+const origin = { origin: base };
+const PASSWORD = "Podokit3e-Str0ng!pw";
+// The rate-limit module's default ceiling for /api/auth/* per window. Listing
+// sessions through Better Auth took 1 + one request per user from that budget;
+// the sessions endpoint takes one general request per page.
+const DEFAULT_AUTH_RATE_LIMIT = 20;
+
+type SessionItem = {
+  id: string;
+  userId: string;
+  userEmail: string;
+  createdAt: string;
+  [key: string]: unknown;
+};
+type SessionPage = { items: SessionItem[]; nextCursor: string | null; total: number };
+
+async function signedIn(
+  playwright: PlaywrightWorkerArgs["playwright"],
+  account: { email: string; password: string },
+): Promise<APIRequestContext> {
+  const context = await playwright.request.newContext({ baseURL: base, extraHTTPHeaders: origin });
+  expect((await context.post("/api/auth/sign-in/email", { data: account })).ok()).toBeTruthy();
+  return context;
+}
+
+test("admin pages through every user's session with a few requests outside the auth budget", async ({
+  playwright,
+  disposableUsers,
+}) => {
+  test.setTimeout(180_000);
+  const prefix = `sess-page-${Date.now()}`;
+  const userCount = 27;
+  const pageSize = 10;
+  const userIds = new Set<string>();
+  const signIns = await playwright.request.newContext({ baseURL: base, extraHTTPHeaders: origin });
+  for (let index = 0; index < userCount; index += 1) {
+    const email = `${prefix}-${String(index).padStart(2, "0")}@example.com`;
+    userIds.add(await disposableUsers.create({ email, name: `Session pager ${index}` }));
+    expect((await signIns.post("/api/auth/sign-in/email", { data: { email, password: PASSWORD } })).ok())
+      .toBeTruthy();
+  }
+  await signIns.dispose();
+
+  const admin = await signedIn(playwright, ADMIN);
+  const seen: SessionItem[] = [];
+  let requests = 0;
+  let cursor: string | null = null;
+  do {
+    const query = new URLSearchParams({ limit: String(pageSize), search: prefix });
+    if (cursor) query.set("cursor", cursor);
+    const response = await admin.get(`/api/admin/sessions?${query.toString()}`);
+    requests += 1;
+    expect(response.status()).toBe(200);
+    const remaining = response.headers()["ratelimit-remaining"];
+    if (remaining !== undefined) expect(Number(remaining)).toBeGreaterThan(0);
+    const page = (await response.json()) as SessionPage;
+    expect(page.total).toBe(userCount);
+    for (const item of page.items) expect(item).not.toHaveProperty("token");
+    seen.push(...page.items);
+    cursor = page.nextCursor;
+  } while (cursor && requests <= userCount);
+
+  expect(requests).toBe(Math.ceil(userCount / pageSize));
+  expect(requests).toBeLessThan(DEFAULT_AUTH_RATE_LIMIT);
+  expect(new Set(seen.map((item) => item.id)).size).toBe(userCount);
+  expect(new Set(seen.map((item) => item.userId))).toEqual(userIds);
+  const created = seen.map((item) => Date.parse(item.createdAt));
+  expect(created).toEqual([...created].sort((left, right) => right - left));
+  await admin.dispose();
+});
+
+test("a normal user cannot list or revoke sessions", async ({ playwright }) => {
+  const user = await signedIn(playwright, USER);
+  expect((await user.get("/api/admin/sessions")).status()).toBe(403);
+  expect((await user.delete("/api/admin/sessions/any-session")).status()).toBe(403);
+  await user.dispose();
+});
+
+test("admin revokes a session by id and the action is audited", async ({ playwright, disposableUsers }) => {
+  const email = `sess-revoke-${Date.now()}@example.com`;
+  const userId = await disposableUsers.create({ email, name: "Revoke by id" });
+  const theirs = await signedIn(playwright, { email, password: PASSWORD });
+  const admin = await signedIn(playwright, ADMIN);
+
+  const listed = await admin.get(`/api/admin/sessions?userId=${encodeURIComponent(userId)}`);
+  expect(listed.ok()).toBeTruthy();
+  const page = (await listed.json()) as SessionPage;
+  expect(page.items).toHaveLength(1);
+  const sessionId = page.items[0]?.id ?? "";
+
+  const revoked = await admin.delete(`/api/admin/sessions/${encodeURIComponent(sessionId)}`);
+  expect(revoked.status()).toBe(204);
+  expect(await (await theirs.get("/api/auth/get-session")).json()).toBeNull();
+  expect((await admin.delete(`/api/admin/sessions/${encodeURIComponent(sessionId)}`)).status()).toBe(404);
+
+  // The revoke runs through Better Auth, so the audit-log module records it when
+  // the module is installed and auditing is on.
+  const capabilities = (await (await admin.get("/api/account/capabilities")).json()) as { auditLog?: boolean };
+  const audit = await admin.get("/api/audit-logs");
+  if (capabilities.auditLog === true && audit.ok()) {
+    const body = (await audit.json()) as unknown;
+    const entries = (Array.isArray(body) ? body : (body as { items?: unknown[] }).items ?? []) as Array<{
+      action?: string;
+      actorEmail?: string | null;
+    }>;
+    expect(entries.some((entry) => entry.action === "user.session_revoke" && entry.actorEmail === ADMIN.email))
+      .toBeTruthy();
+  }
+  await theirs.dispose();
+  await admin.dispose();
+});
+
+test("a forged cursor is rejected", async ({ playwright }) => {
+  const admin = await signedIn(playwright, ADMIN);
+  const response = await admin.get("/api/admin/sessions?cursor=forged");
+  expect(response.status()).toBe(400);
+  expect((await response.json())?.error?.code).toBe("ADMIN_SESSION_CURSOR_INVALID");
+  await admin.dispose();
+});

package/dist/templates/modules/admin-dashboard/files/tests/api/admin-users.api.spec.ts

@@ -0,0 +1,86 @@
+import type { APIRequestContext, PlaywrightWorkerArgs } from "@playwright/test";
+import { expect, test } from "../helpers/disposable-users";
+import { ADMIN, USER } from "../helpers/accounts";
+
+const base = process.env.E2E_BASE_URL ?? "http://localhost:5001";
+const origin = { origin: base };
+
+type UserItem = {
+  id: string;
+  email: string;
+  role: string | null;
+  banned: boolean;
+  signupApproved: boolean;
+  [key: string]: unknown;
+};
+type UserPage = { items: UserItem[]; total: number };
+
+async function signedIn(
+  playwright: PlaywrightWorkerArgs["playwright"],
+  account: { email: string; password: string },
+): Promise<APIRequestContext> {
+  const context = await playwright.request.newContext({ baseURL: base, extraHTTPHeaders: origin });
+  expect((await context.post("/api/auth/sign-in/email", { data: account })).ok()).toBeTruthy();
+  return context;
+}
+
+async function list(admin: APIRequestContext, query: Record<string, string>): Promise<UserPage> {
+  const response = await admin.get(`/api/admin/users?${new URLSearchParams(query).toString()}`);
+  expect(response.status(), await response.text()).toBe(200);
+  return (await response.json()) as UserPage;
+}
+
+test("the admin user list combines role and status filters with a search", async ({
+  playwright,
+  disposableUsers,
+}) => {
+  const prefix = `users-filter-${Date.now()}`;
+  const ids = {
+    activeAdmin: await disposableUsers.create({ email: `${prefix}-a@example.com`, role: "admin" }),
+    bannedAdmin: await disposableUsers.create({ email: `${prefix}-b@example.com`, role: "admin" }),
+    activeUser: await disposableUsers.create({ email: `${prefix}-c@example.com` }),
+    pendingUser: await disposableUsers.create({ email: `${prefix}-d@example.com` }),
+  };
+  const admin = await signedIn(playwright, ADMIN);
+  try {
+    expect((await admin.post("/api/auth/admin/ban-user", { data: { userId: ids.bannedAdmin } })).ok())
+      .toBeTruthy();
+    expect((await admin.post("/api/auth/admin/update-user", {
+      data: { userId: ids.pendingUser, data: { signupApproved: false } },
+    })).ok()).toBeTruthy();
+
+    const matching = async (role: string, status: string): Promise<string[]> =>
+      (await list(admin, { search: prefix.toUpperCase(), role, status })).items.map((user) => user.id);
+    expect(await matching("admin", "active")).toEqual([ids.activeAdmin]);
+    expect(await matching("admin", "banned")).toEqual([ids.bannedAdmin]);
+    expect(await matching("user", "pending")).toEqual([ids.pendingUser]);
+    expect(await matching("user", "active")).toEqual([ids.activeUser]);
+
+    const all = await list(admin, { search: prefix, limit: "2", sortBy: "email", sortDirection: "asc" });
+    expect(all.total).toBe(4);
+    expect(all.items.map((user) => user.id)).toEqual([ids.activeAdmin, ids.bannedAdmin]);
+    const banned = all.items[1];
+    expect(banned?.banned).toBe(true);
+    expect(banned?.signupApproved).toBe(true);
+    expect(banned).not.toHaveProperty("password");
+  } finally {
+    await admin.dispose();
+  }
+});
+
+test("the admin user list is for administrators and validates its query", async ({ playwright }) => {
+  const anonymous = await playwright.request.newContext({ baseURL: base, extraHTTPHeaders: origin });
+  const user = await signedIn(playwright, USER);
+  const admin = await signedIn(playwright, ADMIN);
+  try {
+    expect((await anonymous.get("/api/admin/users")).status()).toBe(401);
+    expect((await user.get("/api/admin/users")).status()).toBe(403);
+    for (const query of ["status=deleted", "sortBy=password", "limit=101"]) {
+      expect((await admin.get(`/api/admin/users?${query}`)).status(), query).toBe(400);
+    }
+  } finally {
+    await anonymous.dispose();
+    await user.dispose();
+    await admin.dispose();
+  }
+});