added rest and graphql endpoints for study rooms

Sanskar Mishra · Sanskar Mishra · commit fb93afb7c7a5 · 2024-11-12T11:28:15.000-08:00
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
@@ -45,6 +45,7 @@ Thank you for your interest in contributing to Anteater API!
    ```
 
    If the checksum does not match, the database dump may be corrupt or have been tampered with. You should delete it immediately and try downloading it again.
+   n
 
 5. Start the local Postgres database.
 
diff --git a/apps/api/src/graphql/resolvers/index.ts b/apps/api/src/graphql/resolvers/index.ts
@@ -3,6 +3,7 @@ import { coursesResolvers } from "$graphql/resolvers/courses";
 import { enrollmentHistoryResolvers } from "$graphql/resolvers/enrollment-history";
 import { gradesResolvers } from "$graphql/resolvers/grades";
 import { instructorsResolvers } from "$graphql/resolvers/instructors";
+import { studyRoomsResolvers } from "$graphql/resolvers/study-rooms";
 import { websocResolvers } from "$graphql/resolvers/websoc";
 import { weekResolvers } from "$graphql/resolvers/week";
 import { mergeResolvers } from "@graphql-tools/merge";
@@ -15,4 +16,5 @@ export const resolvers = mergeResolvers([
   instructorsResolvers,
   websocResolvers,
   weekResolvers,
+  studyRoomsResolvers,
 ]);
diff --git a/apps/api/src/graphql/resolvers/study-rooms.ts b/apps/api/src/graphql/resolvers/study-rooms.ts
@@ -0,0 +1,27 @@
+import type { GraphQLContext } from "$graphql/graphql-context";
+import { studyRoomsQuerySchema } from "$schema";
+import { StudyRoomsService } from "$services";
+import { GraphQLError } from "graphql/error";
+
+export const studyRoomsResolvers = {
+  Query: {
+    studyRoom: async (_: unknown, { id }: { id: string }, { db }: GraphQLContext) => {
+      const service = new StudyRoomsService(db);
+      const res = await service.getStudyRoomById(id);
+      if (!res)
+        throw new GraphQLError(`Study room '${id}' not found`, {
+          extensions: { code: "NOT_FOUND" },
+        });
+      return res;
+    },
+    studyRooms: async (_: unknown, args: { query: unknown }, { db }: GraphQLContext) => {
+      const service = new StudyRoomsService(db);
+      const validatedQuery = studyRoomsQuerySchema.parse(args.query); // Validate and parse the input
+      return await service.getStudyRooms(validatedQuery);
+    },
+    allStudyRooms: async (_: unknown, __: unknown, { db }: GraphQLContext) => {
+      const service = new StudyRoomsService(db);
+      return await service.getAllStudyRooms();
+    },
+  },
+};
diff --git a/apps/api/src/graphql/schema/index.ts b/apps/api/src/graphql/schema/index.ts
@@ -5,6 +5,7 @@ import { enrollmentHistorySchema } from "./enrollment-history";
 import { enums } from "./enums";
 import { gradesSchema } from "./grades";
 import { instructorsSchema } from "./instructors";
+import { studyRoomsGraphQLSchema } from "./study-rooms";
 import { websocSchema } from "./websoc";
 import { weekSchema } from "./week";
 
@@ -36,4 +37,5 @@ export const typeDefs = mergeTypeDefs([
   instructorsSchema,
   websocSchema,
   weekSchema,
+  studyRoomsGraphQLSchema,
 ]);
diff --git a/apps/api/src/graphql/schema/study-rooms.ts b/apps/api/src/graphql/schema/study-rooms.ts
@@ -0,0 +1,32 @@
+export const studyRoomsGraphQLSchema = `#graphql
+  type Slot {
+    studyRoomId: String!
+    start: String!
+    end: String!
+    isAvailable: Boolean!
+  }
+
+  type StudyRoom {
+    id: String!
+    name: String!
+    capacity: Int!
+    location: String!
+    description: String
+    directions: String
+    techEnhanced: Boolean!
+    slots: [Slot!]!
+  }
+
+  input StudyRoomsQuery {
+    location: String
+    capacityMin: Int
+    capacityMax: Int
+    isTechEnhanced: Boolean
+  }
+
+  extend type Query {
+    studyRoom(id: String!): StudyRoom!
+    studyRooms(query: StudyRoomsQuery!): [StudyRoom!]!
+    allStudyRooms: [StudyRoom!]!
+  }
+`;
diff --git a/apps/api/src/rest/index.ts b/apps/api/src/rest/index.ts
@@ -7,6 +7,7 @@ import { enrollmentHistoryRouter } from "./routes/enrollment-history";
 import { gradesRouter } from "./routes/grades";
 import { instructorsRouter } from "./routes/instructors";
 import { pingRouter } from "./routes/ping";
+import { studyRoomsRouter } from "./routes/study-rooms";
 import { websocRouter } from "./routes/websoc";
 import { weekRouter } from "./routes/week";
 
@@ -20,5 +21,6 @@ restRouter.route("/instructors", instructorsRouter);
 restRouter.route("/ping", pingRouter);
 restRouter.route("/websoc", websocRouter);
 restRouter.route("/week", weekRouter);
+restRouter.route("/study-rooms", studyRoomsRouter);
 
 export { restRouter };
diff --git a/apps/api/src/rest/routes/study-rooms.ts b/apps/api/src/rest/routes/study-rooms.ts
@@ -0,0 +1,129 @@
+import { defaultHook } from "$hooks";
+import { productionCache } from "$middleware";
+import {
+  errorSchema,
+  responseSchema,
+  studyRoomSchema,
+  studyRoomsPathSchema,
+  studyRoomsQuerySchema,
+} from "$schema";
+import { StudyRoomsService } from "$services";
+import type { Bindings } from "$types/bindings";
+import { OpenAPIHono, createRoute } from "@hono/zod-openapi";
+import { database } from "@packages/db";
+
+const studyRoomsRouter = new OpenAPIHono<{ Bindings: Bindings }>({ defaultHook });
+
+const allStudyRoomsRoute = createRoute({
+  summary: "List all study rooms",
+  operationId: "allStudyRooms",
+  tags: ["Study Rooms"],
+  method: "get",
+  path: "/all",
+  description: "Retrieves all available study rooms.",
+  responses: {
+    200: {
+      content: {
+        "application/json": { schema: responseSchema(studyRoomSchema.array()) },
+      },
+      description: "Successful operation",
+    },
+    500: {
+      content: { "application/json": { schema: errorSchema } },
+      description: "Server error occurred",
+    },
+  },
+});
+
+const studyRoomByIdRoute = createRoute({
+  summary: "Retrieve a study room",
+  operationId: "studyRoomById",
+  tags: ["Study Rooms"],
+  method: "get",
+  path: "/{id}",
+  request: { params: studyRoomsPathSchema },
+  description: "Retrieves a study room by its ID.",
+  responses: {
+    200: {
+      content: { "application/json": { schema: responseSchema(studyRoomSchema) } },
+      description: "Successful operation",
+    },
+    404: {
+      content: { "application/json": { schema: errorSchema } },
+      description: "Study room not found",
+    },
+    422: {
+      content: { "application/json": { schema: errorSchema } },
+      description: "Parameters failed validation",
+    },
+    500: {
+      content: { "application/json": { schema: errorSchema } },
+      description: "Server error occurred",
+    },
+  },
+});
+
+const studyRoomsByFiltersRoute = createRoute({
+  summary: "Filter study rooms",
+  operationId: "studyRoomsByFilters",
+  tags: ["Study Rooms"],
+  method: "get",
+  path: "/",
+  request: { query: studyRoomsQuerySchema },
+  description: "Retrieves study rooms matching the given filters.",
+  responses: {
+    200: {
+      content: {
+        "application/json": { schema: responseSchema(studyRoomSchema.array()) },
+      },
+      description: "Successful operation",
+    },
+    422: {
+      content: { "application/json": { schema: errorSchema } },
+      description: "Parameters failed validation",
+    },
+    500: {
+      content: { "application/json": { schema: errorSchema } },
+      description: "Server error occurred",
+    },
+  },
+});
+
+studyRoomsRouter.get(
+  "*",
+  productionCache({ cacheName: "study-room-api", cacheControl: "max-age=86400" }),
+);
+
+studyRoomsRouter.openapi(allStudyRoomsRoute, async (c) => {
+  const service = new StudyRoomsService(database(c.env.DB.connectionString));
+  return c.json(
+    {
+      ok: true,
+      data: studyRoomSchema.array().parse(await service.getAllStudyRooms()),
+    },
+    200,
+  );
+});
+
+studyRoomsRouter.openapi(studyRoomByIdRoute, async (c) => {
+  const { id } = c.req.valid("param");
+  const service = new StudyRoomsService(database(c.env.DB.connectionString));
+  const res = await service.getStudyRoomById(id);
+  return res
+    ? c.json({ ok: true, data: studyRoomSchema.parse(res) }, 200)
+    : c.json({ ok: false, message: `Study room ${id} not found` }, 404);
+});
+
+studyRoomsRouter.openapi(studyRoomsByFiltersRoute, async (c) => {
+  const query = c.req.valid("query");
+  const service = new StudyRoomsService(database(c.env.DB.connectionString));
+  return c.json(
+    {
+      ok: true,
+      data: studyRoomSchema.array().parse(await service.getStudyRooms(query)),
+    },
+    200,
+  );
+});
+
+export { studyRoomsRouter };
diff --git a/apps/api/src/schema/index.ts b/apps/api/src/schema/index.ts
@@ -6,3 +6,4 @@ export * from "./grades";
 export * from "./instructors.ts";
 export * from "./websoc";
 export * from "./week";
+export * from "./study-rooms";
diff --git a/apps/api/src/schema/study-rooms.ts b/apps/api/src/schema/study-rooms.ts
@@ -0,0 +1,34 @@
+import { z } from "@hono/zod-openapi";
+
+export const slotSchema = z.object({
+  studyRoomId: z.string(),
+  start: z.string().openapi({ format: "date-time" }),
+  end: z.string().openapi({ format: "date-time" }),
+  isAvailable: z.boolean(),
+});
+
+export const studyRoomSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  capacity: z.number().int(),
+  location: z.string(),
+  description: z.string().optional(),
+  directions: z.string().optional(),
+  techEnhanced: z.boolean(),
+  slots: z.array(slotSchema).optional(),
+});
+
+export const studyRoomsPathSchema = z.object({
+  id: z.string(),
+});
+
+export const studyRoomsQuerySchema = z
+  .object({
+    location: z.string().optional(),
+    capacityMin: z.coerce.number().int().optional(), // Coerce to number
+    capacityMax: z.coerce.number().int().optional(), // Coerce to number
+    isTechEnhanced: z.coerce.boolean().optional(), // Coerce to boolean
+  })
+  .refine((data) => Object.keys(data).length > 0, {
+    message: "At least one filter must be provided.",
+  });
diff --git a/apps/api/src/services/index.ts b/apps/api/src/services/index.ts
@@ -5,3 +5,4 @@ export * from "./grades";
 export * from "./instructors";
 export * from "./websoc";
 export * from "./week";
+export * from "./study-rooms";
diff --git a/apps/api/src/services/study-rooms.ts b/apps/api/src/services/study-rooms.ts
@@ -0,0 +1,41 @@
+import type { database } from "@packages/db";
+import { and, eq, gte, lte } from "@packages/db/drizzle";
+import { studyRoom } from "@packages/db/schema";
+
+type StudyRoomsServiceInput = {
+  location?: string;
+  capacityMin?: number;
+  capacityMax?: number;
+  isTechEnhanced?: boolean;
+};
+
+export class StudyRoomsService {
+  constructor(private readonly db: ReturnType<typeof database>) {}
+
+  async getAllStudyRooms() {
+    return this.db
+      .select()
+      .from(studyRoom)
+      .then((rows) => rows);
+  }
+
+  async getStudyRoomById(id: string) {
+    const [room] = await this.db.select().from(studyRoom).where(eq(studyRoom.id, id));
+    return room || null;
+  }
+
+  async getStudyRooms(input: StudyRoomsServiceInput) {
+    const conditions = [];
+    if (input.location) conditions.push(eq(studyRoom.location, input.location));
+    if (input.capacityMin) conditions.push(gte(studyRoom.capacity, input.capacityMin));
+    if (input.capacityMax) conditions.push(lte(studyRoom.capacity, input.capacityMax));
+    if (input.isTechEnhanced !== undefined)
+      conditions.push(eq(studyRoom.techEnhanced, input.isTechEnhanced));
+
+    return this.db
+      .select()
+      .from(studyRoom)
+      .where(and(...conditions))
+      .then((rows) => rows);
+  }
+}
