Feature/106 user dashboard

.env.example

@@ -5,7 +5,7 @@ STRIPE_PRICE_ID=
 STRIPE_SECRET_KEY=
 NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=
 
-WORDPRESS_API_URL=http://xxx.com
+WORDPRESS_API_URL=https://example.com
 WORDPRESS_USERNAME=mcld-dashboard
 WORDPRESS_APP_PASSWORD="xxxx xxxx xxxx xxxx xxxx xxxx"
 WORDPRESS_POST_TYPE=posts

.gitignore

@@ -15,6 +15,8 @@
 /.next/
 /out/
 
+/.react-email
+
 # production
 /build
 
@@ -50,8 +52,6 @@ next-env.d.ts
 *.swo
 *~
 
-# drizzle
-drizzle/meta/
 
 # supabase
 .supabase/

__tests__/services-actions.test.ts

@@ -0,0 +1,224 @@
+/**
+ * @jest-environment node
+ */
+import {
+   createService,
+   updateService,
+} from "@/app/(authenticated)/services/actions";
+
+// db mock
+const insertValues = jest.fn().mockResolvedValue(undefined);
+const insert = jest.fn(() => ({ values: insertValues })) as jest.Mock;
+
+const selectLimit = jest.fn();
+const selectWhere = jest.fn(() => ({ limit: selectLimit }));
+const selectFrom = jest.fn(() => ({ where: selectWhere }));
+const select = jest.fn(() => ({ from: selectFrom })) as jest.Mock;
+
+const updateWhere = jest.fn().mockResolvedValue(undefined);
+const updateSet = jest.fn(() => ({ where: updateWhere }));
+const update = jest.fn(() => ({ set: updateSet })) as jest.Mock;
+
+jest.mock("@/lib/db", () => ({
+   db: {
+      insert: (...args: unknown[]) => insert(...args),
+      select: (...args: unknown[]) => select(...args),
+      update: (...args: unknown[]) => update(...args),
+   },
+}));
+
+// stripe mock
+const createProduct = jest.fn();
+const createPrice = jest.fn();
+const updateProduct = jest.fn();
+const replaceProductPrice = jest.fn();
+const getStripeServiceData = jest.fn();
+
+jest.mock("@/lib/stripe", () => ({
+   createProduct: (...args: unknown[]) => createProduct(...args),
+   createPrice: (...args: unknown[]) => createPrice(...args),
+   updateProduct: (...args: unknown[]) => updateProduct(...args),
+   replaceProductPrice: (...args: unknown[]) => replaceProductPrice(...args),
+   getStripeServiceData: (...args: unknown[]) => getStripeServiceData(...args),
+}));
+
+// auth + cache mocks
+const requireAdmin = jest.fn();
+jest.mock("@/lib/auth/require-admin", () => ({
+   requireAdmin: (...args: unknown[]) => requireAdmin(...args),
+}));
+
+jest.mock("next/cache", () => ({
+   revalidatePath: jest.fn(),
+   updateTag: jest.fn(),
+}));
+
+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 {
+   const f = new FormData();
+   for (const [k, v] of Object.entries(obj)) f.append(k, v);
+   return f;
+}
+
+beforeEach(() => {
+   jest.clearAllMocks();
+   requireAdmin.mockResolvedValue(undefined);
+   createProduct.mockResolvedValue({ productId: "prod_1" });
+   createPrice.mockResolvedValue(undefined);
+   updateProduct.mockResolvedValue(undefined);
+   replaceProductPrice.mockResolvedValue({ priceId: "price_new" });
+   getStripeServiceData.mockResolvedValue({ priceCents: 5000 });
+});
+
+describe("createService", () => {
+   it("rejects a private lesson without a coordinator", async () => {
+      const result = await createService(
+         null,
+         fd({
+            title: "1:1 Lesson",
+            description: "A private session",
+            type: "private_lessons",
+            duration_minutes: "60",
+            price_cad: "50.00",
+         }),
+      );
+
+      expect(result?.errors?.coordinator_id).toBeDefined();
+      expect(insert).not.toHaveBeenCalled();
+      expect(createProduct).not.toHaveBeenCalled();
+   });
+
+   it("persists the coordinator when creating a private lesson", async () => {
+      const result = await createService(
+         null,
+         fd({
+            title: "1:1 Lesson",
+            description: "A private session",
+            type: "private_lessons",
+            duration_minutes: "60",
+            price_cad: "50.00",
+            requires_subscription: "true",
+            coordinator_id: COORDINATOR_A,
+         }),
+      );
+
+      expect(result).toEqual({ message: "Service created." });
+      expect(insertValues).toHaveBeenCalledWith(
+         expect.objectContaining({
+            type: "private_lessons",
+            coordinatorId: COORDINATOR_A,
+         }),
+      );
+   });
+
+   it("creates a program with no coordinator", async () => {
+      const result = await createService(
+         null,
+         fd({
+            title: "Summer Program",
+            description: "Group program",
+            type: "programs",
+            duration_minutes: "60",
+            price_cad: "100.00",
+            start_date: "2026-01-01",
+            end_date: "2026-02-01",
+            slots: JSON.stringify([{ dayOfWeek: 1, time: "10:00" }]),
+            requires_subscription: "true",
+         }),
+      );
+
+      expect(result).toEqual({ message: "Service created." });
+      expect(insertValues).toHaveBeenCalledWith(
+         expect.objectContaining({ type: "programs", coordinatorId: null }),
+      );
+   });
+});
+
+describe("updateService", () => {
+   it("reassigns the coordinator on a private lesson", async () => {
+      selectLimit.mockResolvedValue([
+         {
+            id: SERVICE_ID,
+            type: "private_lessons",
+            status: "active",
+            stripeProductId: "prod_1",
+         },
+      ]);
+
+      const result = await updateService(
+         null,
+         fd({ service_id: SERVICE_ID, coordinator_id: COORDINATOR_B }),
+      );
+
+      expect(result).toEqual({ message: "Service updated." });
+      expect(updateSet).toHaveBeenCalledWith(
+         expect.objectContaining({ coordinatorId: COORDINATOR_B }),
+      );
+   });
+
+   it("does not recreate the Stripe price when the amount is unchanged", async () => {
+      selectLimit.mockResolvedValue([
+         {
+            id: SERVICE_ID,
+            type: "private_lessons",
+            status: "active",
+            stripeProductId: "prod_1",
+         },
+      ]);
+      getStripeServiceData.mockResolvedValue({ priceCents: 5000 });
+
+      const result = await updateService(
+         null,
+         fd({
+            service_id: SERVICE_ID,
+            coordinator_id: COORDINATOR_B,
+            price_cad: "50.00",
+         }),
+      );
+
+      expect(result).toEqual({ message: "Service updated." });
+      expect(replaceProductPrice).not.toHaveBeenCalled();
+   });
+
+   it("recreates the Stripe price when the amount changes", async () => {
+      selectLimit.mockResolvedValue([
+         {
+            id: SERVICE_ID,
+            type: "private_lessons",
+            status: "active",
+            stripeProductId: "prod_1",
+         },
+      ]);
+      getStripeServiceData.mockResolvedValue({ priceCents: 5000 });
+
+      const result = await updateService(
+         null,
+         fd({ service_id: SERVICE_ID, price_cad: "75.00" }),
+      );
+
+      expect(result).toEqual({ message: "Service updated." });
+      expect(replaceProductPrice).toHaveBeenCalledWith("prod_1", 7500);
+   });
+
+   it("rejects clearing the coordinator on a private lesson", async () => {
+      selectLimit.mockResolvedValue([
+         {
+            id: SERVICE_ID,
+            type: "private_lessons",
+            status: "active",
+            stripeProductId: "prod_1",
+         },
+      ]);
+
+      const result = await updateService(
+         null,
+         fd({ service_id: SERVICE_ID, coordinator_id: "" }),
+      );
+
+      expect(result?.errors?.coordinator_id).toBeDefined();
+      expect(updateSet).not.toHaveBeenCalled();
+   });
+});

__tests__/users-actions.test.ts

@@ -0,0 +1,90 @@
+/**
+ * @jest-environment node
+ */
+import { deleteUserAdmin } from "@/app/(authenticated)/users/actions";
+
+// db mock
+const selectLimit = jest.fn();
+const selectWhere = jest.fn(() => ({ limit: selectLimit }));
+const selectFrom = jest.fn(() => ({ where: selectWhere }));
+const select = jest.fn(() => ({ from: selectFrom })) as jest.Mock;
+
+jest.mock("@/lib/db", () => ({
+   db: {
+      select: (...args: unknown[]) => select(...args),
+   },
+}));
+
+// supabase admin mock
+const deleteUser = jest.fn();
+jest.mock("@/utils/supabase/admin", () => ({
+   createAdminClient: () => ({
+      auth: { admin: { deleteUser: (...args: unknown[]) => deleteUser(...args) } },
+   }),
+}));
+
+// auth + cache + stripe mocks
+const requireAdmin = jest.fn();
+jest.mock("@/lib/auth/require-admin", () => ({
+   requireAdmin: (...args: unknown[]) => requireAdmin(...args),
+}));
+
+jest.mock("next/cache", () => ({ revalidatePath: jest.fn() }));
+
+// actions.ts imports grantComplimentarySubscription from @/lib/stripe, which
+// instantiates the Stripe client at module load.
+jest.mock("@/lib/stripe", () => ({
+   grantComplimentarySubscription: jest.fn(),
+}));
+
+const COORDINATOR_ID = "11111111-1111-1111-1111-111111111111";
+
+function fd(obj: Record<string, string>): FormData {
+   const f = new FormData();
+   for (const [k, v] of Object.entries(obj)) f.append(k, v);
+   return f;
+}
+
+beforeEach(() => {
+   jest.clearAllMocks();
+   requireAdmin.mockResolvedValue(undefined);
+   selectLimit.mockResolvedValue([]);
+   deleteUser.mockResolvedValue({ error: null });
+});
+
+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: COORDINATOR_ID }));
+
+      expect(result).toEqual({ errors: { _form: ["Unauthorized"] } });
+      expect(deleteUser).not.toHaveBeenCalled();
+   });
+
+   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: COORDINATOR_ID }));
+
+      expect(result?.errors?._form?.[0]).toMatch(/private lesson/i);
+      expect(deleteUser).not.toHaveBeenCalled();
+   });
+
+   it("deletes the user when not assigned to any private lesson", async () => {
+      selectLimit.mockResolvedValue([]);
+
+      const result = await deleteUserAdmin(null, fd({ user_id: COORDINATOR_ID }));
+
+      expect(result).toEqual({ message: "User deleted." });
+      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: COORDINATOR_ID }));
+
+      expect(result).toEqual({ errors: { _form: ["boom"] } });
+   });
+});

app/(authenticated)/account/_components/status-badge.tsx

@@ -0,0 +1,21 @@
+import { Badge } from "@/components/ui/badge";
+
+const STATUS_CLASS: Record<string, string> = {
+   confirmed: "bg-green-700/80 text-white",
+   completed: "bg-green-700/80 text-white",
+   pending: "bg-amber-700/80 text-white",
+   awaiting_payment: "bg-amber-700/80 text-white",
+   cancelled: "bg-muted text-muted-foreground",
+};
+
+export function StatusBadge({ status }: { status: string }) {
+   return (
+      <Badge
+         className={
+            STATUS_CLASS[status] ?? "bg-secondary/80 text-secondary-foreground"
+         }
+      >
+         {status.replace(/_/g, " ")}
+      </Badge>
+   );
+}