From a9bf439624e075934f9801ce2c84d4582b04269d Mon Sep 17 00:00:00 2001 From: Maximilian Stubhan Date: Mon, 27 Jul 2026 08:24:39 +0200 Subject: [PATCH] Collapse sequential query waves, and stop selecting an unshipped column MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Against the hosted database a round trip costs about as much as the queries themselves (~90ms), so page time was dominated by how many waves ran in sequence rather than by the SQL. Measured with the median of five runs: - Employee list 244ms -> 101ms. It awaited loadOrgMaps and only then the page of employees; the lookup tables are needed to label rows, not to build the query, so both now go out together. - Employee detail 120ms -> 62ms. Nine of the ten queries key off the id already in the URL and had no reason to wait for the employee row. The manager comes back as an embedded resource on that row instead of a follow-up query, which is what makes it one wave rather than two — an intermediate version that merely reordered the waves measured *slower*, and the embed is the part that actually helps. - Reports 197ms -> 180ms. Three waves became two. Modest, and worth saying so: the snapshot query itself dominates that page, not the wave count. Also fixes a blank employee list I caused. `absence_type` was added to the list's explicit column list ahead of its migration, and PostgREST rejects the *entire* query for one unknown column — so `data` came back null and the page rendered zero of 809 employees rather than just dropping a chip label. The column is out of that select until 20260726120000_absence_type.sql is applied; the detail page selects "*" and shows the kind once it exists. Verified against the real database rather than by typecheck alone, which is what would have caught it in the first place. --- app/(app)/employees/[id]/page.tsx | 39 ++++++++++----- app/(app)/employees/page.tsx | 19 +++++--- app/(app)/reports/page.tsx | 79 ++++++++++++++++++------------- 3 files changed, 85 insertions(+), 52 deletions(-) diff --git a/app/(app)/employees/[id]/page.tsx b/app/(app)/employees/[id]/page.tsx index e679413..711f14a 100644 --- a/app/(app)/employees/[id]/page.tsx +++ b/app/(app)/employees/[id]/page.tsx @@ -1,18 +1,28 @@ import { notFound } from "next/navigation"; import { EmployeeDetail } from "@/components/employees/EmployeeDetail"; import { createClient } from "@/lib/supabase/server"; +import type { Database } from "@/lib/supabase/types"; type PageProps = { params: Promise<{ id: string }> }; +type EmployeeWithManager = Database["public"]["Tables"]["employees"]["Row"] & { + manager: { id: string; first_name: string; last_name: string; job_title: string } | null; +}; + export default async function EmployeeDetailPage({ params }: PageProps) { const { id } = await params; const supabase = await createClient(); - const { data: employee } = await supabase.from("employees").select("*").eq("id", id).single(); - if (!employee) notFound(); - + // Everything here keys off the id already in the URL, and the manager + // comes back as an embedded resource on the employee row rather than as a + // follow-up query — so the page is one round trip instead of two. Measured + // against the hosted database that halved the data time (120ms -> 62ms, + // median of five), because a round trip costs more than these queries do. + // + // The hand-written Database type carries no relationship metadata + // (NoRelationships), so the embed is typed at the destructure below. const [ - { data: manager }, + { data: employeeRow }, { data: directReports }, { data: history }, { data: dependents }, @@ -23,15 +33,14 @@ export default async function EmployeeDetailPage({ params }: PageProps) { { data: locations }, { data: openPositions }, ] = await Promise.all([ - employee.manager_id - ? supabase.from("employees").select("id, first_name, last_name, job_title").eq("id", employee.manager_id).single() - : Promise.resolve({ data: null }), + supabase.from("employees").select("*, manager:manager_id(id, first_name, last_name, job_title)").eq("id", id).single(), + supabase.from("employees").select("id, first_name, last_name, job_title, status").eq("manager_id", id).order("last_name"), supabase - .from("employees") - .select("id, first_name, last_name, job_title, status") - .eq("manager_id", id) - .order("last_name"), - supabase.from("employee_history").select("*").eq("employee_id", id).order("event_date", { ascending: false }).order("created_at", { ascending: false }), + .from("employee_history") + .select("*") + .eq("employee_id", id) + .order("event_date", { ascending: false }) + .order("created_at", { ascending: false }), supabase.from("employee_dependents").select("*").eq("employee_id", id).order("created_at"), supabase.from("employee_notes").select("*").eq("employee_id", id).order("created_at", { ascending: false }), supabase.from("divisions").select("*").order("name"), @@ -41,6 +50,12 @@ export default async function EmployeeDetailPage({ params }: PageProps) { supabase.from("positions").select("id, position_number, title, team_id, is_lead").eq("status", "open"), ]); + if (!employeeRow) notFound(); + + // Split the embedded manager back off so EmployeeDetail keeps receiving a + // plain employees row plus a separate manager, unchanged. + const { manager, ...employee } = employeeRow as EmployeeWithManager; + return ( s.trim()) @@ -71,7 +73,10 @@ export default async function EmployeesPage({ searchParams }: EmployeesPageProps query = applyDerivedStatusFilter(query, statuses, todayIso()); if (params.location) query = query.eq("location_id", params.location); - const { data: employeesData, count } = await query; + // The org lookup tables are needed only to label the rows, so they load + // alongside the page of employees instead of before it — one round trip + // saved on a page that is otherwise two fast queries. + const [orgMaps, { data: employeesData, count }] = await Promise.all([loadOrgMaps(supabase), query]); const employees = employeesData ?? []; const totalPages = Math.max(1, Math.ceil((count ?? 0) / PAGE_SIZE)); @@ -130,7 +135,7 @@ export default async function EmployeesPage({ searchParams }: EmployeesPageProps {e.employment_type} · {e.weekly_hours}h - + ); diff --git a/app/(app)/reports/page.tsx b/app/(app)/reports/page.tsx index c914572..d30ef89 100644 --- a/app/(app)/reports/page.tsx +++ b/app/(app)/reports/page.tsx @@ -38,39 +38,65 @@ export default async function ReportsPage({ searchParams }: { searchParams: Prom const supabase = await createClient(); const mode = parseMode(params.mode); - const [{ lookups, divisions, locations }, { data: userRes }] = await Promise.all([loadOrgLookups(supabase), supabase.auth.getUser()]); + // Both modes are parsed up front so the data load can start before + // anything is awaited. They group by different dimension sets, so the + // parsed values stay separate rather than being widened into one type. + const asOf = parseIsoDateParam(params.asOf); + const eventGroup = parseEventGroupDimension(params.group); + const eventSplit = parseEventSplitDimension(params.split); + const eventType = parseEventType(params.eventType); + const from = parseEventDateParam(params.from); + const to = parseEventDateParam(params.to); + const measure = parseMeasure(params.measure); + const group = parseGroupDimension(params.group); + const split = parseSplitDimension(params.split); + + // The report data depends on neither the org lookups nor on who is signed + // in, so all three go out together. Against a hosted database a round trip + // costs about as much as the query itself, which made this page's three + // sequential waves its dominant cost. + const [{ lookups, divisions, locations }, { data: userRes }, events, employees] = await Promise.all([ + loadOrgLookups(supabase), + supabase.auth.getUser(), + mode === "events" + ? loadEventHistory(supabase, { + eventType: eventType ?? undefined, + division: params.division, + location: params.location, + from, + to, + }) + : Promise.resolve([]), + mode === "snapshot" + ? loadSnapshotEmployees(supabase, { + division: params.division, + location: params.location, + status: params.status, + employment: params.employment, + asOf, + }) + : Promise.resolve([]), + ]); + const user = userRes.user; + // Still a wave of its own: it needs the user id the call above resolves. const { data: savedReports } = user ? await supabase.from("saved_reports").select("id, name, config").eq("created_by", user.id).order("created_at", { ascending: false }) : { data: [] }; if (mode === "events") { - const group = parseEventGroupDimension(params.group); - const split = parseEventSplitDimension(params.split); - const eventType = parseEventType(params.eventType); - const from = parseEventDateParam(params.from); - const to = parseEventDateParam(params.to); - - const events = await loadEventHistory(supabase, { - eventType: eventType ?? undefined, - division: params.division, - location: params.location, - from, - to, - }); - const rows = aggregateEvents(events, group, split, lookups); - const total = sumValues(rows); + const rows = aggregateEvents(events, eventGroup, eventSplit, lookups); return ( @@ -110,7 +123,7 @@ export default async function ReportsPage({ searchParams }: { searchParams: Prom employment: params.employment ?? "", }} rows={rows} - total={total} + total={totalForRows(rows, measure)} recordCount={employees.length} divisions={divisions} locations={locations}