refactor(services): rename coach references to coordinator and update related logic in actions, tests, and components

Author: martin0024

__tests__/services-actions.test.ts

@@ -54,8 +54,8 @@ jest.mock("next/cache", () => ({
    updateTag: jest.fn(),
 }));
 
-const COACH_A = "11111111-1111-1111-1111-111111111111";
-const COACH_B = "22222222-2222-2222-2222-222222222222";
+const COORDINATOR_A = "11111111-1111-1111-1111-111111111111";
+const COORDINATOR_B = "22222222-2222-2222-2222-222222222222";
 const SERVICE_ID = "33333333-3333-3333-3333-333333333333";
 
 function fd(obj: Record<string, string>): FormData {
@@ -75,7 +75,7 @@ beforeEach(() => {
 });
 
 describe("createService", () => {
-   it("rejects a private lesson without a coach", async () => {
+   it("rejects a private lesson without a coordinator", async () => {
       const result = await createService(
          null,
          fd({
@@ -87,12 +87,12 @@ describe("createService", () => {
          }),
       );
 
-      expect(result?.errors?.coach_id).toBeDefined();
+      expect(result?.errors?.coordinator_id).toBeDefined();
       expect(insert).not.toHaveBeenCalled();
       expect(createProduct).not.toHaveBeenCalled();
    });
 
-   it("persists the coach when creating a private lesson", async () => {
+   it("persists the coordinator when creating a private lesson", async () => {
       const result = await createService(
          null,
          fd({
@@ -101,17 +101,17 @@ describe("createService", () => {
             type: "private_lessons",
             duration_minutes: "60",
             price_cad: "50.00",
-            coach_id: COACH_A,
+            coordinator_id: COORDINATOR_A,
          }),
       );
 
       expect(result).toEqual({ message: "Service created." });
       expect(insertValues).toHaveBeenCalledWith(
-         expect.objectContaining({ type: "private_lessons", coachId: COACH_A }),
+         expect.objectContaining({ type: "private_lessons", coordinatorId: COORDINATOR_A }),
       );
    });
 
-   it("creates a program with no coach", async () => {
+   it("creates a program with no coordinator", async () => {
       const result = await createService(
          null,
          fd({
@@ -128,13 +128,13 @@ describe("createService", () => {
 
       expect(result).toEqual({ message: "Service created." });
       expect(insertValues).toHaveBeenCalledWith(
-         expect.objectContaining({ type: "programs", coachId: null }),
+         expect.objectContaining({ type: "programs", coordinatorId: null }),
       );
    });
 });
 
 describe("updateService", () => {
-   it("reassigns the coach on a private lesson", async () => {
+   it("reassigns the coordinator on a private lesson", async () => {
       selectLimit.mockResolvedValue([
          {
             id: SERVICE_ID,
@@ -146,12 +146,12 @@ describe("updateService", () => {
 
       const result = await updateService(
          null,
-         fd({ service_id: SERVICE_ID, coach_id: COACH_B }),
+         fd({ service_id: SERVICE_ID, coordinator_id: COORDINATOR_B }),
       );
 
       expect(result).toEqual({ message: "Service updated." });
       expect(updateSet).toHaveBeenCalledWith(
-         expect.objectContaining({ coachId: COACH_B }),
+         expect.objectContaining({ coordinatorId: COORDINATOR_B }),
       );
    });
 
@@ -168,7 +168,7 @@ describe("updateService", () => {
 
       const result = await updateService(
          null,
-         fd({ service_id: SERVICE_ID, coach_id: COACH_B, price_cad: "50.00" }),
+         fd({ service_id: SERVICE_ID, coordinator_id: COORDINATOR_B, price_cad: "50.00" }),
       );
 
       expect(result).toEqual({ message: "Service updated." });
@@ -197,7 +197,7 @@ describe("updateService", () => {
       expect(createPrice).toHaveBeenCalledWith("prod_1", 7500);
    });
 
-   it("rejects clearing the coach on a private lesson", async () => {
+   it("rejects clearing the coordinator on a private lesson", async () => {
       selectLimit.mockResolvedValue([
          {
             id: SERVICE_ID,
@@ -209,10 +209,10 @@ describe("updateService", () => {
 
       const result = await updateService(
          null,
-         fd({ service_id: SERVICE_ID, coach_id: "" }),
+         fd({ service_id: SERVICE_ID, coordinator_id: "" }),
       );
 
-      expect(result?.errors?.coach_id).toBeDefined();
+      expect(result?.errors?.coordinator_id).toBeDefined();
       expect(updateSet).not.toHaveBeenCalled();
    });
 });

__tests__/users-actions.test.ts

@@ -37,7 +37,7 @@ jest.mock("@/lib/stripe", () => ({
    grantComplimentarySubscription: jest.fn(),
 }));
 
-const COACH_ID = "11111111-1111-1111-1111-111111111111";
+const COORDINATOR_ID = "11111111-1111-1111-1111-111111111111";
 
 function fd(obj: Record<string, string>): FormData {
    const f = new FormData();
@@ -56,16 +56,16 @@ describe("deleteUserAdmin", () => {
    it("returns Unauthorized when the caller is not an admin", async () => {
       requireAdmin.mockRejectedValue(new Error("Forbidden"));
 
-      const result = await deleteUserAdmin(null, fd({ user_id: COACH_ID }));
+      const result = await deleteUserAdmin(null, fd({ user_id: COORDINATOR_ID }));
 
       expect(result).toEqual({ errors: { _form: ["Unauthorized"] } });
       expect(deleteUser).not.toHaveBeenCalled();
    });
 
-   it("blocks deletion when the coach is assigned to a private lesson", async () => {
+   it("blocks deletion when the coordinator is assigned to a private lesson", async () => {
       selectLimit.mockResolvedValue([{ id: "svc-1" }]);
 
-      const result = await deleteUserAdmin(null, fd({ user_id: COACH_ID }));
+      const result = await deleteUserAdmin(null, fd({ user_id: COORDINATOR_ID }));
 
       expect(result?.errors?._form?.[0]).toMatch(/private lesson/i);
       expect(deleteUser).not.toHaveBeenCalled();
@@ -74,16 +74,16 @@ describe("deleteUserAdmin", () => {
    it("deletes the user when not assigned to any private lesson", async () => {
       selectLimit.mockResolvedValue([]);
 
-      const result = await deleteUserAdmin(null, fd({ user_id: COACH_ID }));
+      const result = await deleteUserAdmin(null, fd({ user_id: COORDINATOR_ID }));
 
       expect(result).toEqual({ message: "User deleted." });
-      expect(deleteUser).toHaveBeenCalledWith(COACH_ID);
+      expect(deleteUser).toHaveBeenCalledWith(COORDINATOR_ID);
    });
 
    it("surfaces an auth error from Supabase", async () => {
       deleteUser.mockResolvedValue({ error: { message: "boom" } });
 
-      const result = await deleteUserAdmin(null, fd({ user_id: COACH_ID }));
+      const result = await deleteUserAdmin(null, fd({ user_id: COORDINATOR_ID }));
 
       expect(result).toEqual({ errors: { _form: ["boom"] } });
    });

app/(authenticated)/services/actions.ts

@@ -118,16 +118,18 @@ function parseProgramSchedule(formData: FormData): ParseResult<ProgramSchedule>
    };
 }
 
-function parseCoachId(formData: FormData): ParseResult<string> {
-   const raw = field(formData, "coach_id");
+function parseCoordinatorId(formData: FormData): ParseResult<string> {
+   const raw = field(formData, "coordinator_id");
    if (!raw)
       return {
          ok: false,
-         errors: { coach_id: ["A coach is required for private lessons"] },
+         errors: {
+            coordinator_id: ["A coordinator is required for private lessons"],
+         },
       };
    const result = z.string().uuid().safeParse(raw);
    if (!result.success) {
-      return { ok: false, errors: { coach_id: ["Invalid coach"] } };
+      return { ok: false, errors: { coordinator_id: ["Invalid coordinator"] } };
    }
    return { ok: true, value: result.data };
 }
@@ -156,7 +158,7 @@ export async function createService(
    }
 
    // Validate price format independently so its error reports alongside
-   // schedule/coach errors instead of in a separate round-trip.
+   // schedule/coordinator errors instead of in a separate round-trip.
    const priceRaw = formData.get("price_cad")?.toString() ?? "";
    let cents: number | null = null;
    if (priceRaw && !errors.price_cad) {
@@ -166,11 +168,11 @@ export async function createService(
       }
    }
 
-   // Schedule / coach checks key off the submitted type, not parsed.data,
+   // Schedule / coordinator checks key off the submitted type, not parsed.data,
    // so they still run when baseFields fails on unrelated fields.
    const typeRaw = formData.get("type")?.toString();
    let scheduledAtValue: ProgramSchedule | null = null;
-   let coachIdValue: string | null = null;
+   let coordinatorIdValue: string | null = null;
    if (typeRaw === "programs") {
       const result = parseProgramSchedule(formData);
       if (!result.ok) {
@@ -179,9 +181,9 @@ export async function createService(
          scheduledAtValue = result.value;
       }
    } else if (typeRaw === "private_lessons") {
-      const coach = parseCoachId(formData);
-      if (!coach.ok) Object.assign(errors, coach.errors);
-      else coachIdValue = coach.value;
+      const coordinator = parseCoordinatorId(formData);
+      if (!coordinator.ok) Object.assign(errors, coordinator.errors);
+      else coordinatorIdValue = coordinator.value;
    }
 
    if (Object.keys(errors).length > 0) {
@@ -210,7 +212,7 @@ export async function createService(
          slots: scheduledAtValue?.slots ?? null,
          durationMinutes: duration_minutes,
          stripeProductId: productId,
-         coachId: coachIdValue,
+         coordinatorId: coordinatorIdValue,
          status: "active",
       });
    } catch (e) {
@@ -306,20 +308,23 @@ export async function updateService(
    }
 
    let scheduledAtValue: ProgramSchedule | undefined;
-   let coachIdValue: string | undefined;
+   let coordinatorIdValue: string | undefined;
    if (row.type === "programs" && formData.has("start_date")) {
       const result = parseProgramSchedule(formData);
       if (!result.ok) {
          Object.assign(errors, result.errors);
       } else {
          scheduledAtValue = result.value;
       }
-   } else if (row.type === "private_lessons" && formData.has("coach_id")) {
-      // Private lessons can be reassigned to a different coach, but the coach
-      // remains mandatory: an empty/invalid value is rejected.
-      const coach = parseCoachId(formData);
-      if (!coach.ok) Object.assign(errors, coach.errors);
-      else coachIdValue = coach.value;
+   } else if (
+      row.type === "private_lessons" &&
+      formData.has("coordinator_id")
+   ) {
+      // Private lessons can be reassigned to a different coordinator, but the
+      // coordinator remains mandatory: an empty/invalid value is rejected.
+      const coordinator = parseCoordinatorId(formData);
+      if (!coordinator.ok) Object.assign(errors, coordinator.errors);
+      else coordinatorIdValue = coordinator.value;
    }
 
    if (Object.keys(errors).length > 0) {
@@ -350,13 +355,13 @@ export async function updateService(
 
       const dbPatch: Partial<typeof services.$inferInsert> = {};
       if (duration_minutes !== undefined) dbPatch.durationMinutes = duration_minutes;
-      if (coachIdValue !== undefined) dbPatch.coachId = coachIdValue;
+      if (coordinatorIdValue !== undefined)
+         dbPatch.coordinatorId = coordinatorIdValue;
       if (scheduledAtValue !== undefined) {
          dbPatch.startDate = scheduledAtValue.startDate;
          dbPatch.endDate = scheduledAtValue.endDate;
          dbPatch.slots = scheduledAtValue.slots;
       }
-      if (coachIdValue !== undefined) dbPatch.coachId = coachIdValue;
 
       if (Object.keys(dbPatch).length > 0) {
          dbPatch.updatedAt = new Date();

app/(authenticated)/services/page.tsx

@@ -1,16 +1,16 @@
-import { listCoaches, listServices } from "./queries";
+import { listCoordinators, listServices } from "./queries";
 import { ServicesTable } from "./services-table";
 
 export default async function ServicesPage() {
-   const [services, coaches] = await Promise.all([
+   const [services, coordinators] = await Promise.all([
       listServices(),
-      listCoaches(),
+      listCoordinators(),
    ]);
 
    return (
       <main className="flex min-h-screen flex-col gap-6 p-8">
          <h1 className="text-3xl font-bold">Services</h1>
-         <ServicesTable services={services} coaches={coaches} />
+         <ServicesTable services={services} coordinators={coordinators} />
       </main>
    );
 }

app/(authenticated)/services/queries.ts

@@ -9,7 +9,7 @@ const SERVICES_TAG = "services";
 
 const UUID_RE =
    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-const COACHES_TAG = "coaches";
+const COORDINATORS_TAG = "coordinators";
 
 export type ServiceStatus = "active" | "disabled" | "archived" | "deleted";
 export type ServiceType = "private_lessons" | "programs";
@@ -21,7 +21,7 @@ export type ServiceView = {
    durationMinutes: number;
    status: ServiceStatus;
    stripeProductId: string;
-   coachId: string | null;
+   coordinatorId: string | null;
    createdAt: Date;
    updatedAt: Date;
    title: string | null;
@@ -52,7 +52,7 @@ async function buildServiceView(
       durationMinutes: row.durationMinutes,
       status: row.status,
       stripeProductId: row.stripeProductId,
-      coachId: row.coachId,
+      coordinatorId: row.coordinatorId,
       createdAt: row.createdAt,
       updatedAt: row.updatedAt,
       title: stripeData?.title ?? null,
@@ -111,21 +111,21 @@ export async function getService(id: string): Promise<ServiceView | null> {
    return buildServiceView(row);
 }
 
-export type CoachOption = {
+export type CoordinatorOption = {
    id: string;
    firstName: string;
    lastName: string;
 };
 
 /**
- * List all profiles with the `coach` role, ordered by name.
+ * List all profiles with the `coordinator` role, ordered by name.
  *
- * Cached via Next Cache Components; bust via the `coaches` tag when
- * coach assignments change.
+ * Cached via Next Cache Components; bust via the `coordinators` tag when
+ * coordinator assignments change.
  */
-export async function listCoaches(): Promise<CoachOption[]> {
+export async function listCoordinators(): Promise<CoordinatorOption[]> {
    "use cache";
-   cacheTag(COACHES_TAG);
+   cacheTag(COORDINATORS_TAG);
 
    return db
       .select({
@@ -134,6 +134,6 @@ export async function listCoaches(): Promise<CoachOption[]> {
          lastName: profiles.lastName,
       })
       .from(profiles)
-      .where(eq(profiles.role, "coach"))
+      .where(eq(profiles.role, "coordinator"))
       .orderBy(asc(profiles.firstName), asc(profiles.lastName));
 }