feat: add pagination to user list + estimated heartbeat count

Author: ImShyMike

frontend/src/lib/types/admin.ts

@@ -8,4 +8,6 @@ export interface AdminResponse {
 	requests_per_second: number;
 	daily_activity: Array<{ date: string; count: number }>;
 	all_users: Array<PartialUser>;
+	limit: number;
+	offset: number;
 }

frontend/src/routes/admin/+page.server.ts

@@ -3,13 +3,16 @@ import type { AdminResponse } from '$lib/types/admin';
 import { createApi, ApiError } from '$lib/api/api';
 import { redirect, error } from '@sveltejs/kit';
 
-export const load: PageServerLoad = async ({ fetch, depends, request }) => {
+export const load: PageServerLoad = async ({ fetch, depends, request, url }) => {
 	depends('app:admin');
 
+	const limit = parseInt(url.searchParams.get('limit') || '50', 10);
+	const offset = parseInt(url.searchParams.get('offset') || '0', 10);
+
 	try {
 		const cookieHeader = request.headers.get('cookie') || undefined;
 		const api = createApi(fetch, cookieHeader);
-		return await api.get<AdminResponse>('/page/admin');
+		return await api.get<AdminResponse>(`/page/admin?limit=${limit}&offset=${offset}`);
 	} catch (e) {
 		console.error('Error loading admin page data:', e);
 		const err = e as ApiError;

frontend/src/routes/admin/+page.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
 	import { tick } from 'svelte';
 	import { browser } from '$app/environment';
-	import { invalidate } from '$app/navigation';
+	import { invalidate, goto } from '$app/navigation';
 	import { apexcharts } from '$lib/stores/apexcharts';
 	import { theme } from '$lib/stores/theme';
 	import type { Theme } from '$lib/stores/theme';
@@ -21,7 +21,8 @@
 		UserTag,
 		DataTable,
 		EmptyState,
-		Button
+		Button,
+		Pagination
 	} from '$lib';
 	import { auth } from '$lib/stores/auth';
 	import { impersonateUser, changeAdminLevel } from '$lib/api/admin';
@@ -94,6 +95,15 @@
 		}
 	});
 
+	const currentOffset = $derived(adminData.offset);
+	const limit = $derived(adminData.limit);
+	const total = $derived(adminData.total_users);
+
+	function goToPage(offset: number) {
+		// eslint-disable-next-line svelte/no-navigation-without-resolve
+		goto(`/admin?offset=${offset}&limit=${limit}`);
+	}
+
 	async function initializeCharts(theme: Theme) {
 		if (!browser) {
 			return;
@@ -160,7 +170,7 @@
 			<div class="md:col-span-2 lg:col-span-1">
 				<StatCard
 					title="Total Heartbeats"
-					value={adminData.total_heartbeats.toLocaleString()}
+					value={`~${adminData.total_heartbeats.toLocaleString()}`}
 					valueClass="text-3xl font-bold text-ctp-green-600"
 				/>
 			</div>
@@ -191,11 +201,7 @@
 			<Container>
 				<SectionTitle className="mb-4">Users</SectionTitle>
 				<DataTable {columns} tableClassName="min-w-lg">
-					{#each [...adminData.all_users].sort((a, b) => {
-						const adminDiff = (b.admin_level ?? 0) - (a.admin_level ?? 0);
-						if (adminDiff !== 0) return adminDiff;
-						return a.id - b.id;
-					}) as user (user.id)}
+					{#each adminData.all_users as user (user.id)}
 						<tr class="border-b border-ctp-surface0 last:border-0 hover:bg-ctp-surface0/50">
 							<td class="pl-6 py-4 whitespace-nowrap text-sm text-ctp-subtext1">{user.id}</td>
 							<td class="px-6 py-4 whitespace-nowrap">
@@ -275,6 +281,14 @@
 						</tr>
 					{/each}
 				</DataTable>
+
+				<Pagination
+					offset={currentOffset}
+					{limit}
+					{total}
+					className="mt-4"
+					onchange={(newOffset) => goToPage(newOffset)}
+				/>
 			</Container>
 		{:else}
 			<EmptyState

rustytime/Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "rustytime-server"
 description = "🕒 blazingly fast time tracking for developers"
-version = "0.15.1"
+version = "0.15.2"
 edition = "2024"
 authors = ["ImShyMike"]
 readme = "../README.md"

rustytime/Cargo.toml

@@ -1,6 +1,6 @@
 use aide::NoApi;
 use axum::Json;
-use axum::extract::Path;
+use axum::extract::{Path, Query};
 use axum::{
     Extension,
     extract::State,
@@ -9,7 +9,7 @@ use axum::{
 };
 
 use schemars::JsonSchema;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use tower_cookies::Cookies;
 
 use crate::models::heartbeat::Heartbeat;
@@ -20,6 +20,18 @@ use crate::utils::cache::CachedAdminStats;
 use crate::utils::session::{ImpersonationContext, SessionManager};
 use crate::{db_query, get_db_conn};
 
+#[derive(Deserialize, JsonSchema)]
+pub struct AdminQuery {
+    #[serde(default = "default_limit")]
+    pub limit: i64,
+    #[serde(default)]
+    pub offset: i64,
+}
+
+fn default_limit() -> i64 {
+    50
+}
+
 #[derive(Serialize, JsonSchema)]
 pub struct FormattedDailyActivity {
     pub date: String,
@@ -35,10 +47,13 @@ pub struct AdminDashboardResponse {
     pub requests_per_second: f64,
     pub daily_activity: Vec<FormattedDailyActivity>,
     pub all_users: Vec<PartialUser>,
+    pub limit: i64,
+    pub offset: i64,
 }
 
 pub async fn admin_dashboard(
     State(app_state): State<AppState>,
+    Query(query): Query<AdminQuery>,
     user: NoApi<Option<Extension<User>>>,
 ) -> Result<Json<AdminDashboardResponse>, Response> {
     // check if user is an admin
@@ -52,60 +67,58 @@ pub async fn admin_dashboard(
     }
 
     let include_api_key = current_user.is_owner();
+    let limit = query.limit.clamp(1, 100);
+    let offset = query.offset.max(0);
 
     let cached = app_state.cache.admin.get(&());
-    let (
-        total_users,
-        total_heartbeats,
-        heartbeats_last_hour,
-        heartbeats_last_24h,
-        daily_activity,
-        all_users,
-    ) = if let Some(cached) = cached {
-        (
-            cached.total_users,
-            cached.total_heartbeats,
-            cached.heartbeats_last_hour,
-            cached.heartbeats_last_24h,
-            cached.daily_activity,
-            cached.all_users,
-        )
-    } else {
-        let mut conn = get_db_conn!(app_state);
-
-        let raw_daily_activity = db_query!(
-            Heartbeat::get_daily_activity_last_week(&mut conn),
-            "Failed to fetch daily activity"
-        );
-        let all_users = db_query!(User::list_all_users(&mut conn), "Failed to fetch users");
-        let total_users = db_query!(User::count_total_users(&mut conn, false));
-        let total_heartbeats = db_query!(Heartbeat::count_total_heartbeats(&mut conn));
-        let heartbeats_last_hour = db_query!(Heartbeat::count_heartbeats_last_hour(&mut conn));
-        let heartbeats_last_24h = db_query!(Heartbeat::count_heartbeats_last_24h(&mut conn));
-
-        app_state.cache.admin.insert(
-            (),
-            CachedAdminStats {
+    let (total_users, total_heartbeats, heartbeats_last_hour, heartbeats_last_24h, daily_activity) =
+        if let Some(cached) = cached {
+            (
+                cached.total_users,
+                cached.total_heartbeats,
+                cached.heartbeats_last_hour,
+                cached.heartbeats_last_24h,
+                cached.daily_activity,
+            )
+        } else {
+            let mut conn = get_db_conn!(app_state);
+
+            let raw_daily_activity = db_query!(
+                Heartbeat::get_daily_activity_last_week(&mut conn),
+                "Failed to fetch daily activity"
+            );
+            let total_users = db_query!(User::count_total_users(&mut conn, false));
+            let total_heartbeats = db_query!(Heartbeat::count_total_heartbeats_estimate(&mut conn));
+            let heartbeats_last_hour = db_query!(Heartbeat::count_heartbeats_last_hour(&mut conn));
+            let heartbeats_last_24h = db_query!(Heartbeat::count_heartbeats_last_24h(&mut conn));
+
+            app_state.cache.admin.insert(
+                (),
+                CachedAdminStats {
+                    total_users,
+                    total_heartbeats,
+                    heartbeats_last_hour,
+                    heartbeats_last_24h,
+                    daily_activity: raw_daily_activity.clone(),
+                },
+            );
+
+            (
                 total_users,
                 total_heartbeats,
                 heartbeats_last_hour,
                 heartbeats_last_24h,
-                daily_activity: raw_daily_activity.clone(),
-                all_users: all_users.clone(),
-            },
-        );
-
-        (
-            total_users,
-            total_heartbeats,
-            heartbeats_last_hour,
-            heartbeats_last_24h,
-            raw_daily_activity,
-            all_users,
-        )
-    };
+                raw_daily_activity,
+            )
+        };
+
+    let mut conn = get_db_conn!(app_state);
+    let paginated_users = db_query!(
+        User::list_users_paginated(&mut conn, limit, offset),
+        "Failed to fetch users"
+    );
 
-    let partial_users = all_users
+    let partial_users = paginated_users
         .iter()
         .map(|user| PartialUser {
             id: user.id,
@@ -137,6 +150,8 @@ pub async fn admin_dashboard(
             / 1000.0,
         daily_activity,
         all_users: partial_users,
+        limit,
+        offset,
     }))
 }
 

rustytime/src/handlers/page/admin.rs

@@ -12,6 +12,12 @@ use crate::schema::heartbeats::{self};
 use crate::utils::http::parse_user_agent;
 use crate::utils::time::{TimeFormat, human_readable_duration};
 
+#[derive(QueryableByName)]
+struct ApproximateRowCount {
+    #[diesel(sql_type = BigInt)]
+    count: i64,
+}
+
 diesel::define_sql_function! {
     /// Calculate user duration with filters
     #[allow(clippy::too_many_arguments)]
@@ -756,8 +762,10 @@ impl From<Heartbeat> for BulkResponseItem {
 }
 
 impl Heartbeat {
-    pub fn count_total_heartbeats(conn: &mut PgConnection) -> QueryResult<i64> {
-        heartbeats::table.count().get_result(conn)
+    pub fn count_total_heartbeats_estimate(conn: &mut PgConnection) -> QueryResult<i64> {
+        diesel::sql_query("SELECT approximate_row_count('heartbeats') AS count")
+            .get_result::<ApproximateRowCount>(conn)
+            .map(|r| r.count)
     }
 
     pub fn count_heartbeats_last_24h(conn: &mut PgConnection) -> QueryResult<i64> {

rustytime/src/models/heartbeat.rs

@@ -103,8 +103,17 @@ impl User {
         self.admin_level > 1
     }
 
-    pub fn list_all_users(conn: &mut PgConnection) -> QueryResult<Vec<User>> {
-        users::table.load::<User>(conn)
+    pub fn list_users_paginated(
+        conn: &mut PgConnection,
+        limit: i64,
+        offset: i64,
+    ) -> QueryResult<Vec<User>> {
+        users::table
+            .order(users::admin_level.desc())
+            .then_order_by(users::id.asc())
+            .limit(limit)
+            .offset(offset)
+            .load::<User>(conn)
     }
 
     pub fn get_by_ids(

rustytime/src/models/user.rs

@@ -38,7 +38,6 @@ pub struct CachedAdminStats {
     pub heartbeats_last_hour: i64,
     pub heartbeats_last_24h: i64,
     pub daily_activity: Vec<DailyActivity>,
-    pub all_users: Vec<User>,
 }
 
 #[derive(Clone)]