Feature/119 coordinator availability backend

__tests__/coordinator-availability-actions.test.ts

@@ -0,0 +1,150 @@
+/**
+ * @jest-environment node
+ */
+import { updateCoordinatorAvailability } from "@/app/coaching/actions";
+
+const COORDINATOR_ID = "11111111-1111-1111-1111-111111111111";
+const OTHER_COORDINATOR_ID = "22222222-2222-2222-2222-222222222222";
+const ADMIN_ID = "33333333-3333-3333-3333-333333333333";
+
+const onConflictDoUpdate = jest.fn().mockResolvedValue(undefined);
+const insertValues = jest.fn(() => ({ onConflictDoUpdate }));
+const insert = jest.fn(() => ({ values: insertValues })) as jest.Mock;
+
+jest.mock("@/lib/db", () => ({
+   db: {
+      insert: (...args: unknown[]) => insert(...args),
+   },
+}));
+
+const getUser = jest.fn();
+const getClaims = jest.fn();
+jest.mock("@/utils/supabase/server", () => ({
+   createClient: async () => ({ auth: { getUser, getClaims } }),
+}));
+
+const emptyWeek = {
+   0: [],
+   1: [],
+   2: [],
+   3: [],
+   4: [],
+   5: [],
+   6: [],
+};
+
+beforeEach(() => {
+   jest.clearAllMocks();
+});
+
+describe("updateCoordinatorAvailability", () => {
+   it("returns Unauthorized when not signed in", async () => {
+      getUser.mockResolvedValue({ data: { user: null } });
+      getClaims.mockResolvedValue({ data: { claims: null } });
+
+      const result = await updateCoordinatorAvailability({
+         coordinatorId: COORDINATOR_ID,
+         slots: emptyWeek,
+      });
+
+      expect(result).toEqual({ error: "Unauthorized" });
+      expect(insert).not.toHaveBeenCalled();
+   });
+
+   it("returns Unauthorized for a parent", async () => {
+      getUser.mockResolvedValue({
+         data: { user: { id: COORDINATOR_ID } },
+      });
+      getClaims.mockResolvedValue({
+         data: { claims: { user_role: "user" } },
+      });
+
+      const result = await updateCoordinatorAvailability({
+         coordinatorId: COORDINATOR_ID,
+         slots: emptyWeek,
+      });
+
+      expect(result).toEqual({ error: "Unauthorized" });
+      expect(insert).not.toHaveBeenCalled();
+   });
+
+   it("lets a coordinator save their own slots", async () => {
+      getUser.mockResolvedValue({
+         data: { user: { id: COORDINATOR_ID } },
+      });
+      getClaims.mockResolvedValue({
+         data: { claims: { user_role: "coordinator" } },
+      });
+
+      const result = await updateCoordinatorAvailability({
+         coordinatorId: COORDINATOR_ID,
+         slots: emptyWeek,
+      });
+
+      expect(result).toEqual({ ok: true });
+      expect(insertValues).toHaveBeenCalledWith(
+         expect.objectContaining({ coordinatorId: COORDINATOR_ID }),
+      );
+   });
+
+   it("blocks a coordinator from saving another coordinator's slots", async () => {
+      getUser.mockResolvedValue({
+         data: { user: { id: COORDINATOR_ID } },
+      });
+      getClaims.mockResolvedValue({
+         data: { claims: { user_role: "coordinator" } },
+      });
+
+      const result = await updateCoordinatorAvailability({
+         coordinatorId: OTHER_COORDINATOR_ID,
+         slots: emptyWeek,
+      });
+
+      expect(result).toEqual({ error: "Unauthorized" });
+      expect(insert).not.toHaveBeenCalled();
+   });
+
+   it("lets an admin save any coordinator's slots", async () => {
+      getUser.mockResolvedValue({
+         data: { user: { id: ADMIN_ID } },
+      });
+      getClaims.mockResolvedValue({
+         data: { claims: { user_role: "admin" } },
+      });
+
+      const result = await updateCoordinatorAvailability({
+         coordinatorId: OTHER_COORDINATOR_ID,
+         slots: emptyWeek,
+      });
+
+      expect(result).toEqual({ ok: true });
+      expect(insertValues).toHaveBeenCalledWith(
+         expect.objectContaining({ coordinatorId: OTHER_COORDINATOR_ID }),
+      );
+   });
+
+   it("rejects overlapping slots on the same day", async () => {
+      getUser.mockResolvedValue({
+         data: { user: { id: COORDINATOR_ID } },
+      });
+      getClaims.mockResolvedValue({
+         data: { claims: { user_role: "coordinator" } },
+      });
+
+      const result = await updateCoordinatorAvailability({
+         coordinatorId: COORDINATOR_ID,
+         slots: {
+            ...emptyWeek,
+            1: [
+               { time: "10:00", durationMinutes: 60 },
+               { time: "10:30", durationMinutes: 60 },
+            ],
+         },
+      });
+
+      expect(result).toEqual({
+         error: "Slots on the same day must not overlap",
+      });
+      expect(insert).not.toHaveBeenCalled();
+   });
+});

app/coaching/actions.ts

@@ -1,10 +1,17 @@
 "use server";
+import { updateCoordinatorAvailabilitySchema } from "@/app/coaching/schema";
+import { ROLES } from "@/lib/roles"
 
 import { eq } from "drizzle-orm";
 
 import { db } from "@/lib/db";
-import { coachingSessions, services } from "@/lib/db/schema";
+import {
+   coachingSessions,
+   coordinatorAvailability,
+   services,
+} from "@/lib/db/schema";
 import { createClient } from "@/utils/supabase/server";
+import { Schema } from "zod";
 
 export type Availability = { start: string; end: string };
 
@@ -52,3 +59,51 @@
 
    return { coachingSessionId: row.id };
 }
+
+
+async function canEditCoordinatorAvailability(
+   coordinatorId: string,
+): Promise<boolean> {
+   const supabase = await createClient();
+   const {
+      data: { user },
+   } = await supabase.auth.getUser();
+   if (!user) return false;
+
+   const { data } = await supabase.auth.getClaims();
+   const role = data?.claims?.user_role;
+
+   if (role === ROLES.ADMIN) return true;
+   if (role === ROLES.COORDINATOR && user.id === coordinatorId) return true;
+   return false;
+}
+
+export type UpdateCoordinatorAvailabilityResult =
+   | { ok: true }
+   | { error: string };
+
+export async function updateCoordinatorAvailability(
+   input: unknown,
+): Promise<UpdateCoordinatorAvailabilityResult> {
+   const parsed = updateCoordinatorAvailabilitySchema.safeParse(input);
+   if (!parsed.success) {
+      return {
+         error: parsed.error.issues[0]?.message ?? "Invalid input",
+      };
+   }
+
+   const { coordinatorId, slots } = parsed.data;
+   if (!(await canEditCoordinatorAvailability(coordinatorId))) {
+      return { error: "Unauthorized" };
+   }
+
+   await db
+      .insert(coordinatorAvailability)
+      .values({ coordinatorId, slots })
+      .onConflictDoUpdate({
+         target: coordinatorAvailability.coordinatorId,
+         set: { slots, updatedAt: new Date() },
+      });
+
+   return { ok: true };
+}

app/coaching/schema.ts

@@ -0,0 +1,43 @@
+import {z} from 'zod';
+
+export const availabilitySlotSchema = z.object({
+    time: z.string().regex(/^\d{2}:\d{2}$/, "Invalid time"),
+    durationMinutes: z.number().int().min(1).max(24 * 60),
+ });
+
+ export const weeklyAvailabilitySchema = z
+ .object({
+    0: z.array(availabilitySlotSchema),
+    1: z.array(availabilitySlotSchema),
+    2: z.array(availabilitySlotSchema),
+    3: z.array(availabilitySlotSchema),
+    4: z.array(availabilitySlotSchema),
+    5: z.array(availabilitySlotSchema),
+    6: z.array(availabilitySlotSchema),
+ })
+ .refine((week) => !Object.values(week).some(daySlotsOverlap), {
+    message: "Slots on the same day must not overlap",
+ });
+
+
+ export const updateCoordinatorAvailabilitySchema = z.object({
+    coordinatorId: z.string().uuid(),
+    slots: weeklyAvailabilitySchema,
+ });
+
+ function daySlotsOverlap(
+    slots: z.infer<typeof availabilitySlotSchema>[],
+ ): boolean {
+    const ranges = slots
+       .map((slot) => {
+          const [hours, minutes] = slot.time.split(":").map(Number);
+          const start = hours * 60 + minutes;
+          return { start, end: start + slot.durationMinutes };
+       })
+       .sort((a, b) => a.start - b.start);
+
+    for (let i = 1; i < ranges.length; i++) {
+       if (ranges[i]!.start < ranges[i - 1]!.end) return true;
+    }
+    return false;
+ }

lib/db/schema.ts

@@ -259,3 +259,29 @@ export const formQuestionAnswers = pgTable("form_question_answers", {
    createdAt: timestamp("created_at").defaultNow().notNull(),
    updatedAt: timestamp("updated_at").defaultNow().notNull(),
 });
+
+export type AvailabilitySlot = {
+   time: string;
+   durationMinutes: number;
+};
+
+export type CoordinatorWeeklyAvailability = {
+   0: AvailabilitySlot[];
+   1: AvailabilitySlot[];
+   2: AvailabilitySlot[];
+   3: AvailabilitySlot[];
+   4: AvailabilitySlot[];
+   5: AvailabilitySlot[];
+   6: AvailabilitySlot[];
+};
+
+export const coordinatorAvailability = pgTable("coordinator_availability", {
+   id: uuid("id").primaryKey().defaultRandom(),
+   coordinatorId: uuid("coordinator_id")
+      .references(() => profiles.id, { onDelete: "cascade" })
+      .notNull()
+      .unique(),
+   slots: jsonb("slots").$type<CoordinatorWeeklyAvailability>().notNull(),
+   createdAt: timestamp("created_at").defaultNow().notNull(),
+   updatedAt: timestamp("updated_at").defaultNow().notNull(),
+});