Interview pagination

src/controllers/interview.controller.ts

@@ -3,14 +3,29 @@ import * as interviewService from "../services/interview.service";
 import { ApiError } from "../utils/apiError";
 
 export const getInterviews = async (req: Request, res: Response) => {
-  const interviews = await interviewService.getInterviews();
+  const page = parseInt(req.query.page as string) || 1;
+  const limit = parseInt(req.query.limit as string) || 10;
 
-  res.status(200).json({
+  if(isNaN(page) || page<1){
+    throw new ApiError("Page must be greater than or equal to 1",400);
+  }
+  if(isNaN(limit) || limit<1 || limit>100){
+    throw new ApiError("Limit must be between 1 to 100",400)
+  }
+
+  const { interviews, total } = await interviewService.getInterviews(page, limit);
+
+  return res.status(200).json({
     success: true,
-    data: interviews,
+    data: interviews,     
+    page,
+    limit,
+    total,
+    totalPages: Math.ceil(total / limit),
   });
 };
 
+
 export const getInterviewById = async (req: Request, res: Response) => {
   const interviewId = parseInt(req.params.id);
 

src/services/interview.service.ts

@@ -1,13 +1,39 @@
 import { prisma } from "../db/client"
 
-export const getInterviews = async () => {
-  return await prisma.interviewExperience.findMany({
-    orderBy: {
-      id: "desc",
-    },
-  });
+export const getInterviews = async (page: number = 1, limit: number = 10) => {
+  const skip = (page - 1) * limit;
+
+  const [interviews, total] = await Promise.all([
+    prisma.interviewExperience.findMany({
+      skip,
+      take: limit,
+      include: {
+        member: {
+          select: {
+            id: true,
+            name: true,
+            profilePhoto: true,
+          },
+        },
+      },
+      orderBy: {
+        id: "desc",
+      },
+    }),
+
+    prisma.interviewExperience.count(),
+  ]);
+
+  const formattedInterviews = interviews.map(
+    ({ isAnonymous, member, memberId, ...rest }) => {
+      return isAnonymous ? {...rest,isAnonymous} : { ...rest,isAnonymous, member }; 
+    }
+  );
+
+  return { interviews : formattedInterviews , total };
 };
 
+
 export const getInterviewById = async (interviewId: number) => {
   return await prisma.interviewExperience.findUnique({
     where: {

tests/Interview.test.ts

@@ -5,7 +5,12 @@ import { Verdict } from '../src/generated/prisma';
 
 describe('getInterviews', () => {
   it('should return 200 and all interviews', async () => {
-    const req: any = {};
+    const req: any = {
+      query: {
+        page: '1',
+        limit: '10',
+      },
+    };
     const res: any = {
       status: jest.fn().mockReturnThis(),
       json: jest.fn(),
@@ -19,25 +24,37 @@ describe('getInterviews', () => {
         verdict: Verdict.Selected,
         content: 'Great experience',
         isAnonymous: false,
-        memberId: 'member123',
+        member: {
+          id: 'member123',
+          name: 'John Doe',
+          profilePhoto: null,
+        },
       },
     ];
 
+    const mockReturn = {
+      interviews: mockInterviews,
+      total: 1,
+    };
+
     jest
       .spyOn(interviewService, 'getInterviews')
-      .mockResolvedValue(mockInterviews);
+      .mockResolvedValue(mockReturn);
 
     await getInterviews(req, res);
 
     expect(res.status).toHaveBeenCalledWith(200);
     expect(res.json).toHaveBeenCalledWith({
       success: true,
       data: mockInterviews,
+      page: 1,
+      limit: 10,
+      total: 1,
+      totalPages: Math.ceil(1 / 10),
     });
   });
 });
 
-
 describe('getInterviewById', () => {
   it('should return 200 and the interview if found', async () => {
     const req: any = {