feat: add registration UI (#36)

Author: HJyup

apps/api/src/modules/registration/route.test.ts

@@ -291,6 +291,159 @@ describe("Registration route", () => {
     });
   });
 
+  describe("GET /v1/events/:eventId/registrations", () => {
+    beforeEach(async () => {
+      await db.insert(usersTable).values([
+        { id: "user-1", email: "[email protected]", firstName: "U", lastName: "1" },
+        { id: "user-2", email: "[email protected]", firstName: "U", lastName: "2" },
+      ]);
+
+      await db.insert(eventsTable).values({
+        id: "test-event",
+        title: "Test Event",
+        state: "published",
+        aboutMarkdown: "markdown",
+        organiser: "projectShare",
+        date: new Date(),
+      });
+
+      await db.insert(registrationsTable).values([
+        { userId: "user-1", eventId: "test-event", status: "accepted" },
+        { userId: "user-2", eventId: "test-event", status: "pending" },
+      ]);
+    });
+
+    it("should filter registrations by status query param", async () => {
+      setMockAuth({
+        userId: "committee-user",
+        sessionClaims: { metadata: { role: "committee" } },
+      });
+
+      const response = await app.inject({
+        method: "GET",
+        url: "/v1/events/test-event/registrations",
+        query: { status: "accepted" },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const data = response.json();
+      expect(data).toHaveLength(1);
+      expect(data[0].userId).toBe("user-1");
+      expect(data[0].status).toBe("accepted");
+    });
+
+    it("should filter registrations by userId query param", async () => {
+      setMockAuth({
+        userId: "committee-user",
+        sessionClaims: { metadata: { role: "committee" } },
+      });
+
+      const response = await app.inject({
+        method: "GET",
+        url: "/v1/events/test-event/registrations",
+        query: { userId: "user-2" },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const data = response.json();
+      expect(data).toHaveLength(1);
+      expect(data[0].userId).toBe("user-2");
+    });
+
+    it("should respect pagination limits", async () => {
+      setMockAuth({
+        userId: "committee-user",
+        sessionClaims: { metadata: { role: "committee" } },
+      });
+
+      const response = await app.inject({
+        method: "GET",
+        url: "/v1/events/test-event/registrations",
+        query: { limit: "1" },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const data = response.json();
+      expect(data.length).toBeLessThanOrEqual(1);
+    });
+
+    it("should return empty array if event has no registrations", async () => {
+      setMockAuth({
+        userId: "committee-user",
+        sessionClaims: { metadata: { role: "committee" } },
+      });
+
+      await db.insert(eventsTable).values({
+        id: "empty-event",
+        title: "Empty Event",
+        state: "published",
+        aboutMarkdown: "md",
+        organiser: "projectShare",
+        date: new Date(),
+      });
+
+      const response = await app.inject({
+        method: "GET",
+        url: "/v1/events/empty-event/registrations",
+      });
+
+      expect(response.statusCode).toBe(200);
+      expect(response.json()).toEqual([]);
+    });
+  });
+
+  describe("GET /v1/events/:eventId/registrations/me", () => {
+    beforeEach(async () => {
+      await db.insert(usersTable).values([
+        { id: "test-user", email: "[email protected]", firstName: "Test", lastName: "User" },
+        { id: "other-user", email: "[email protected]", firstName: "Other", lastName: "User" },
+      ]);
+
+      await db.insert(eventsTable).values({
+        id: "test-event",
+        title: "Test Event",
+        state: "published",
+        aboutMarkdown: "markdown",
+        organiser: "projectShare",
+        date: new Date(),
+      });
+
+      await db.insert(registrationsTable).values({
+        userId: "test-user",
+        eventId: "test-event",
+        status: "pending",
+      });
+    });
+
+    it("should return 401 if user is not authenticated", async () => {
+      setMockAuth({ userId: null, sessionClaims: null });
+
+      const response = await app.inject({
+        method: "GET",
+        url: "/v1/events/test-event/registrations/me",
+      });
+
+      expect(response.statusCode).toBe(401);
+    });
+
+    it("should allow a user to fetch their own registration", async () => {
+      setMockAuth({
+        userId: "test-user",
+        sessionClaims: { metadata: { role: "member" } },
+      });
+
+      const response = await app.inject({
+        method: "GET",
+        url: "/v1/events/test-event/registrations/me",
+      });
+
+      expect(response.statusCode).toBe(200);
+      const data = response.json();
+      expect(data.userId).toBe("test-user");
+      expect(data.eventId).toBe("test-event");
+    });
+  });
+
   describe("DELETE /v1/events/:eventId/registrations/:targetUserId", () => {
     beforeEach(async () => {
       await db.insert(usersTable).values([

apps/api/src/modules/registration/route.ts

@@ -4,6 +4,7 @@ import {
   CreateRegistrationSchema,
   RegistrationEventIdSchema,
   RegistrationParamsSchema,
+  RegistrationsQueryFilterSchema,
   UpdateRegistrationSchema,
 } from "./schema.js";
 import { registrationService } from "./service.js";
@@ -39,6 +40,45 @@ export const registrationRoutes = async (server: FastifyInstance) => {
     return reply.status(201).send(registration);
   });
 
+  server.get("/", async (request, reply) => {
+    const { sessionClaims } = getAuth(request);
+    const role = sessionClaims?.metadata?.role;
+
+    const params = RegistrationEventIdSchema.parse(request.params);
+    const filters = RegistrationsQueryFilterSchema.parse(request.query);
+
+    const events = await registrationService.getRegistrations({
+      db: server.db,
+      filters: {
+        id: params.eventId,
+        ...filters,
+      },
+      role: role ?? null,
+    });
+
+    return reply.status(200).send(events);
+  });
+
+  server.get("/me", async (request, reply) => {
+    const { userId, sessionClaims } = getAuth(request);
+    const role = sessionClaims?.metadata?.role;
+
+    if (!userId || !role) {
+      return reply.status(401).send({ message: "Unauthorised" });
+    }
+
+    const data = RegistrationEventIdSchema.parse(request.params);
+    const registration = await registrationService.getRegistrationByUser({
+      db: server.db,
+      data: {
+        ...data,
+        userId,
+      },
+    });
+
+    return registration ? reply.status(200).send(registration) : reply.status(204).send();
+  });
+
   server.put("/:userId", async (request, reply) => {
     const { userId, sessionClaims } = getAuth(request);
     const role = sessionClaims?.metadata?.role;

apps/api/src/modules/registration/schema.ts

@@ -2,6 +2,7 @@ import { createInsertSchema } from "drizzle-zod";
 import { z } from "zod";
 import { registrationsTable } from "../../db/schema.js";
 import { RegistrationStatus } from "@events.comp-soc.com/shared";
+import { UserIdSchema } from "../users/schema.js";
 
 export const BaseRegistrationSchema = createInsertSchema(registrationsTable);
 
@@ -21,6 +22,13 @@ export const UpdateRegistrationSchema = BaseRegistrationSchema.pick({
     status: z.enum(RegistrationStatus).default("pending"),
   });
 
+export const RegistrationsQueryFilterSchema = z.object({
+  userId: UserIdSchema.shape.id.optional(),
+  page: z.coerce.number().min(1).default(1),
+  limit: z.coerce.number().min(1).max(100).default(20),
+  status: z.enum(RegistrationStatus).optional(),
+});
+
 export const RegistrationParamsSchema = z.object({
   userId: BaseRegistrationSchema.shape.userId,
   eventId: BaseRegistrationSchema.shape.eventId,
@@ -33,3 +41,4 @@ export const RegistrationEventIdSchema = z.object({
 export type CreateRegistration = z.infer<typeof CreateRegistrationSchema>;
 export type UpdateRegistration = z.infer<typeof UpdateRegistrationSchema>;
 export type RegistrationParams = z.infer<typeof RegistrationParamsSchema>;
+export type RegistrationsQueryFilter = z.infer<typeof RegistrationsQueryFilterSchema>;

apps/api/src/modules/registration/service.ts

@@ -1,9 +1,15 @@
 import { SqlContext } from "../../db/db.js";
-import { CreateRegistration, RegistrationParams, UpdateRegistration } from "./schema.js";
+import {
+  CreateRegistration,
+  RegistrationParams,
+  RegistrationsQueryFilter,
+  UpdateRegistration,
+} from "./schema.js";
 import { eventStore } from "../events/store.js";
-import { RegistrationStatus, UserRole } from "@events.comp-soc.com/shared";
+import { Nullable, RegistrationStatus, UserRole } from "@events.comp-soc.com/shared";
 import { ConflictError, NotFoundError, UnauthorizedError } from "../../lib/errors.js";
 import { registrationStore } from "./store.js";
+import { EventId } from "../events/schema.js";
 
 export const registrationService = {
   async createRegistration({
@@ -53,6 +59,31 @@ export const registrationService = {
     });
   },
 
+  async getRegistrationByUser({ db, data }: { db: SqlContext; data: RegistrationParams }) {
+    return await registrationStore.getByUserAndEvent({
+      db,
+      data,
+    });
+  },
+
+  async getRegistrations({
+    db,
+    filters,
+    role,
+  }: {
+    db: SqlContext;
+    filters: RegistrationsQueryFilter & Pick<EventId, "id">;
+    role: Nullable<UserRole>;
+  }) {
+    const isCommittee = role === "committee";
+
+    if (!isCommittee) {
+      throw new UnauthorizedError("You do not have permission to view this registration");
+    }
+
+    return registrationStore.get({ db, filters });
+  },
+
   async updateRegistration({
     db,
     data,

apps/api/src/modules/registration/store.ts

@@ -1,25 +1,45 @@
 import { eq, and, count, inArray } from "drizzle-orm";
-import { CreateRegistration, RegistrationParams, UpdateRegistration } from "./schema.js";
+import {
+  CreateRegistration,
+  RegistrationParams,
+  RegistrationsQueryFilter,
+  UpdateRegistration,
+} from "./schema.js";
 import { SqlContext } from "../../db/db.js";
-import { registrationsTable } from "../../db/schema.js";
+import { eventsTable, registrationsTable } from "../../db/schema.js";
 import { EventId } from "../events/schema.js";
 
+export const registrationSelection = {
+  userId: registrationsTable.userId,
+  eventId: registrationsTable.eventId,
+  status: registrationsTable.status,
+  createdAt: registrationsTable.createdAt,
+  updatedAt: registrationsTable.updatedAt,
+  eventTitle: eventsTable.title,
+  eventDate: eventsTable.date,
+  eventLocation: eventsTable.location,
+};
+
 export const registrationStore = {
   async create({ db, data }: { db: SqlContext; data: CreateRegistration }) {
-    const [newRegistration] = await db.insert(registrationsTable).values(data).returning();
+    await db.insert(registrationsTable).values(data).returning();
 
-    return newRegistration;
+    return this.getByUserAndEvent({
+      db,
+      data: { userId: data.userId, eventId: data.eventId },
+    });
   },
 
   async update({ db, data }: { db: SqlContext; data: UpdateRegistration }) {
     const { eventId, userId, ...payload } = data;
-    const [updatedRegistration] = await db
+
+    await db
       .update(registrationsTable)
       .set(payload)
       .where(and(eq(registrationsTable.userId, userId), eq(registrationsTable.eventId, eventId)))
       .returning();
 
-    return updatedRegistration;
+    return this.getByUserAndEvent({ db, data: { userId, eventId } });
   },
 
   async countActiveByEventId({ db, data }: { db: SqlContext; data: EventId }) {
@@ -40,20 +60,48 @@ export const registrationStore = {
   async getByUserAndEvent({ db, data }: { db: SqlContext; data: RegistrationParams }) {
     const { userId, eventId } = data;
     const [registration] = await db
-      .select()
+      .select(registrationSelection)
       .from(registrationsTable)
+      .innerJoin(eventsTable, eq(registrationsTable.eventId, eventsTable.id))
       .where(and(eq(registrationsTable.userId, userId), eq(registrationsTable.eventId, eventId)));
 
     return registration;
   },
 
+  async get({
+    db,
+    filters,
+  }: {
+    db: SqlContext;
+    filters: RegistrationsQueryFilter & Pick<EventId, "id">;
+  }) {
+    const { id, page, limit, status, userId } = filters;
+    const offset = (page - 1) * limit;
+
+    return db
+      .select(registrationSelection)
+      .from(registrationsTable)
+      .innerJoin(eventsTable, eq(registrationsTable.eventId, eventsTable.id))
+      .where(
+        and(
+          eq(registrationsTable.eventId, id),
+          userId ? eq(registrationsTable.userId, userId) : undefined,
+          status ? eq(registrationsTable.status, status) : undefined
+        )
+      )
+      .limit(limit)
+      .offset(offset)
+      .orderBy(registrationsTable.createdAt);
+  },
+
   async delete({ db, data }: { db: SqlContext; data: RegistrationParams }) {
     const { userId, eventId } = data;
-    const [deletedRegistration] = await db
+    const recordToDelete = await this.getByUserAndEvent({ db, data });
+
+    await db
       .delete(registrationsTable)
-      .where(and(eq(registrationsTable.userId, userId), eq(registrationsTable.eventId, eventId)))
-      .returning();
+      .where(and(eq(registrationsTable.userId, userId), eq(registrationsTable.eventId, eventId)));
 
-    return deletedRegistration;
+    return recordToDelete;
   },
 };