Maximilian Stubhan
a9bf439624
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.
75 lines
3.0 KiB
TypeScript
75 lines
3.0 KiB
TypeScript
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();
|
|
|
|
// 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: employeeRow },
|
|
{ data: directReports },
|
|
{ data: history },
|
|
{ data: dependents },
|
|
{ data: notes },
|
|
{ data: divisions },
|
|
{ data: departments },
|
|
{ data: teams },
|
|
{ data: locations },
|
|
{ data: openPositions },
|
|
] = await Promise.all([
|
|
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("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"),
|
|
supabase.from("departments").select("*"),
|
|
supabase.from("teams").select("*"),
|
|
supabase.from("locations").select("*").order("name"),
|
|
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 (
|
|
<EmployeeDetail
|
|
employee={employee}
|
|
manager={manager ?? null}
|
|
directReports={directReports ?? []}
|
|
history={history ?? []}
|
|
dependents={dependents ?? []}
|
|
notes={notes ?? []}
|
|
divisions={divisions ?? []}
|
|
departments={departments ?? []}
|
|
teams={teams ?? []}
|
|
locations={locations ?? []}
|
|
openPositions={openPositions ?? []}
|
|
/>
|
|
);
|
|
}
|