pagination (#117)

* pagination

* reset loans pagination on status tab switch

Author: mirek1112

backend/src/admin/loans.admin.controller.spec.ts

@@ -73,15 +73,21 @@ describe('LoansAdminController', (): void => {
   });
 
   describe('GET /admin/loans', (): void => {
-    it('returns all loans without filter', async (): Promise<void> => {
-      mockService.findAll.mockResolvedValue([mockLoan]);
+    it('returns a paginated list without filter', async (): Promise<void> => {
+      const paginated = { data: [mockLoan], total: 1, page: 1, limit: 20 };
+      mockService.findAll.mockResolvedValue(paginated);
       const result = await controller.findAll({} as FindLoansQueryDto);
       expect(mockService.findAll).toHaveBeenCalledWith({});
-      expect(result).toEqual([mockLoan]);
+      expect(result).toEqual(paginated);
     });
 
     it('passes status filter to service', async (): Promise<void> => {
-      mockService.findAll.mockResolvedValue([]);
+      mockService.findAll.mockResolvedValue({
+        data: [],
+        total: 0,
+        page: 1,
+        limit: 20,
+      });
       await controller.findAll({ status: LoanStatus.Active });
       expect(mockService.findAll).toHaveBeenCalledWith({
         status: LoanStatus.Active,

backend/src/admin/loans.admin.controller.ts

@@ -20,6 +20,7 @@ import { UnknownUserException } from '@/lib/errors';
 import { LoansService } from '@/loans/loans.service';
 import { ExtendLoanDto } from '@/loans/dto/extend-loan.dto';
 import { FindLoansQueryDto } from '@/loans/dto/find-loans-query.dto';
+import { PaginatedLoansResponseDto } from '@/loans/dto/paginated-loans-response.dto';
 import { Loan } from '@/loans/entities/loan.entity';
 
 type FirebaseRequest = { firebaseUser: DecodedIdToken };
@@ -36,7 +37,9 @@ export class LoansAdminController {
   ) {}
 
   @Get()
-  findAll(@Query() query: FindLoansQueryDto): Promise<Loan[]> {
+  findAll(
+    @Query() query: FindLoansQueryDto
+  ): Promise<PaginatedLoansResponseDto> {
     return this.loansService.findAll(query);
   }
 

backend/src/loans/dto/find-loans-query.dto.ts

@@ -1,5 +1,6 @@
 import { ApiPropertyOptional } from '@nestjs/swagger';
-import { IsEnum, IsOptional } from 'class-validator';
+import { Type } from 'class-transformer';
+import { IsEnum, IsInt, IsOptional, Max, Min } from 'class-validator';
 
 export enum LoanStatus {
   Active = 'active',
@@ -12,4 +13,19 @@ export class FindLoansQueryDto {
   @IsOptional()
   @IsEnum(LoanStatus)
   status?: LoanStatus;
+
+  @ApiPropertyOptional({ default: 1, minimum: 1 })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Type(() => Number)
+  page?: number = 1;
+
+  @ApiPropertyOptional({ default: 20, minimum: 1, maximum: 100 })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Max(100)
+  @Type(() => Number)
+  limit?: number = 20;
 }

backend/src/loans/loans.service.spec.ts

@@ -39,12 +39,19 @@ const mockCopy = {
 const mockLoanRepository: jest.Mocked<
   Pick<
     Repository<Loan>,
-    'create' | 'save' | 'find' | 'findOneBy' | 'findOne' | 'createQueryBuilder'
+    | 'create'
+    | 'save'
+    | 'find'
+    | 'findAndCount'
+    | 'findOneBy'
+    | 'findOne'
+    | 'createQueryBuilder'
   >
 > = {
   create: jest.fn(),
   save: jest.fn(),
   find: jest.fn(),
+  findAndCount: jest.fn(),
   findOneBy: jest.fn(),
   findOne: jest.fn(),
   createQueryBuilder: jest.fn(),
@@ -287,43 +294,82 @@ describe('LoansService', (): void => {
   describe('findAll', (): void => {
     const relations = ['copy', 'copy.item', 'copy.location', 'user'];
 
-    it('returns all loans when no status filter', async (): Promise<void> => {
-      mockLoanRepository.find.mockResolvedValue([mockLoan]);
+    it('returns a paginated, borrowed_at DESC ordered list with defaults', async (): Promise<void> => {
+      mockLoanRepository.findAndCount.mockResolvedValue([[mockLoan], 1]);
       const result = await service.findAll({} as FindLoansQueryDto);
-      expect(mockLoanRepository.find).toHaveBeenCalledWith({ relations });
-      expect(result).toEqual([mockLoan]);
+      expect(mockLoanRepository.findAndCount).toHaveBeenCalledWith({
+        relations,
+        order: { borrowed_at: 'DESC' },
+        skip: 0,
+        take: 20,
+      });
+      expect(result).toEqual({
+        data: [mockLoan],
+        total: 1,
+        page: 1,
+        limit: 20,
+      });
+    });
+
+    it('applies page and limit to skip/take', async (): Promise<void> => {
+      mockLoanRepository.findAndCount.mockResolvedValue([[mockLoan], 45]);
+      const result = await service.findAll({
+        page: 3,
+        limit: 10,
+      } as FindLoansQueryDto);
+      expect(mockLoanRepository.findAndCount).toHaveBeenCalledWith({
+        relations,
+        order: { borrowed_at: 'DESC' },
+        skip: 20,
+        take: 10,
+      });
+      expect(result).toEqual({
+        data: [mockLoan],
+        total: 45,
+        page: 3,
+        limit: 10,
+      });
     });
 
     it('filters active loans (not returned, due_date >= today)', async (): Promise<void> => {
-      mockLoanRepository.find.mockResolvedValue([mockLoan]);
+      mockLoanRepository.findAndCount.mockResolvedValue([[mockLoan], 1]);
       await service.findAll({ status: LoanStatus.Active });
-      expect(mockLoanRepository.find).toHaveBeenCalledWith({
+      expect(mockLoanRepository.findAndCount).toHaveBeenCalledWith({
         where: {
           returned_at: IsNull(),
           due_date: MoreThanOrEqual(expect.any(String)),
         },
         relations,
+        order: { borrowed_at: 'DESC' },
+        skip: 0,
+        take: 20,
       });
     });
 
     it('filters returned loans', async (): Promise<void> => {
-      mockLoanRepository.find.mockResolvedValue([]);
+      mockLoanRepository.findAndCount.mockResolvedValue([[], 0]);
       await service.findAll({ status: LoanStatus.Returned });
-      expect(mockLoanRepository.find).toHaveBeenCalledWith({
+      expect(mockLoanRepository.findAndCount).toHaveBeenCalledWith({
         where: { returned_at: Not(IsNull()) },
         relations,
+        order: { borrowed_at: 'DESC' },
+        skip: 0,
+        take: 20,
       });
     });
 
     it('filters overdue loans (not returned, due_date < today)', async (): Promise<void> => {
-      mockLoanRepository.find.mockResolvedValue([]);
+      mockLoanRepository.findAndCount.mockResolvedValue([[], 0]);
       await service.findAll({ status: LoanStatus.Overdue });
-      expect(mockLoanRepository.find).toHaveBeenCalledWith({
+      expect(mockLoanRepository.findAndCount).toHaveBeenCalledWith({
         where: {
           returned_at: IsNull(),
           due_date: LessThan(expect.any(String)),
         },
         relations,
+        order: { borrowed_at: 'DESC' },
+        skip: 0,
+        take: 20,
       });
     });
   });

backend/src/loans/loans.service.ts

@@ -17,6 +17,7 @@ import {
 import { ItemCopy } from '@/item-copies/entities/item-copy.entity';
 import { SlackNotificationsService } from '@/slack-notifications/slack-notifications.service';
 import { FindLoansQueryDto, LoanStatus } from './dto/find-loans-query.dto';
+import { PaginatedLoansResponseDto } from './dto/paginated-loans-response.dto';
 import { Loan } from './entities/loan.entity';
 
 const UNIQUE_VIOLATION_CODES = new Set([
@@ -160,28 +161,32 @@ export class LoansService {
     'user',
   ];
 
-  findAll(query: FindLoansQueryDto): Promise<Loan[]> {
+  async findAll(query: FindLoansQueryDto): Promise<PaginatedLoansResponseDto> {
+    const { status, page = 1, limit = 20 } = query;
     const today = this.today();
     const relations = LoansService.LOAN_RELATIONS;
-    switch (query.status) {
-      case LoanStatus.Active:
-        return this.loanRepository.find({
-          where: { returned_at: IsNull(), due_date: MoreThanOrEqual(today) },
-          relations,
-        });
-      case LoanStatus.Returned:
-        return this.loanRepository.find({
-          where: { returned_at: Not(IsNull()) },
-          relations,
-        });
-      case LoanStatus.Overdue:
-        return this.loanRepository.find({
-          where: { returned_at: IsNull(), due_date: LessThan(today) },
-          relations,
-        });
-      default:
-        return this.loanRepository.find({ relations });
-    }
+
+    const whereByStatus = {
+      [LoanStatus.Active]: {
+        returned_at: IsNull(),
+        due_date: MoreThanOrEqual(today),
+      },
+      [LoanStatus.Returned]: { returned_at: Not(IsNull()) },
+      [LoanStatus.Overdue]: {
+        returned_at: IsNull(),
+        due_date: LessThan(today),
+      },
+    };
+
+    const [data, total] = await this.loanRepository.findAndCount({
+      ...(status ? { where: whereByStatus[status] } : {}),
+      relations,
+      order: { borrowed_at: 'DESC' },
+      skip: (page - 1) * limit,
+      take: limit,
+    });
+
+    return { data, total, page, limit };
   }
 
   async extendLoan(loanId: number, dueDays: number): Promise<Loan> {

backend/test/loans.e2e-spec.ts

@@ -49,6 +49,13 @@ const MOCK_FIREBASE_USER = buildDecodedToken(
 
 type FirebaseRequest = { firebaseUser: DecodedIdToken };
 
+type PaginatedLoans = {
+  data: Loan[];
+  total: number;
+  page: number;
+  limit: number;
+};
+
 async function buildApp(): Promise<{
   app: INestApplication<App>;
   ds: DataSource;
@@ -302,15 +309,47 @@ describe('LoansModule (e2e)', (): void => {
   });
 
   describe('GET /admin/loans', (): void => {
-    it('returns all loans without filter', async (): Promise<void> => {
+    it('returns a paginated list without filter', async (): Promise<void> => {
       await request(app.getHttpServer()).post('/loans').send({ copyId });
 
       await request(app.getHttpServer())
         .get('/admin/loans')
         .expect(StatusCodes.OK)
         .expect((res: Response) => {
-          expect(Array.isArray(res.body)).toBe(true);
-          expect((res.body as Loan[]).length).toBeGreaterThanOrEqual(1);
+          const body = res.body as PaginatedLoans;
+          expect(Array.isArray(body.data)).toBe(true);
+          expect(body.data.length).toBeGreaterThanOrEqual(1);
+          expect(body.total).toBeGreaterThanOrEqual(1);
+          expect(body.page).toBe(1);
+          expect(body.limit).toBe(20);
+        });
+    });
+
+    it('orders loans by borrowed_at DESC', async (): Promise<void> => {
+      await request(app.getHttpServer())
+        .get('/admin/loans')
+        .expect(StatusCodes.OK)
+        .expect((res: Response) => {
+          const { data } = res.body as PaginatedLoans;
+          const borrowedTimes = data.map(loan =>
+            new Date(loan.borrowed_at).getTime()
+          );
+          const sorted = [...borrowedTimes].sort((a, b) => b - a);
+          expect(borrowedTimes).toEqual(sorted);
+        });
+    });
+
+    it('applies page and limit', async (): Promise<void> => {
+      await request(app.getHttpServer()).post('/loans').send({ copyId });
+
+      await request(app.getHttpServer())
+        .get('/admin/loans?page=1&limit=1')
+        .expect(StatusCodes.OK)
+        .expect((res: Response) => {
+          const body = res.body as PaginatedLoans;
+          expect(body.data.length).toBe(1);
+          expect(body.page).toBe(1);
+          expect(body.limit).toBe(1);
         });
     });
 
@@ -321,9 +360,9 @@ describe('LoansModule (e2e)', (): void => {
         .get('/admin/loans?status=active')
         .expect(StatusCodes.OK)
         .expect((res: Response) => {
-          const body = res.body as Loan[];
-          expect(body.length).toBeGreaterThanOrEqual(1);
-          body.forEach(loan => expect(loan.returned_at).toBeNull());
+          const { data } = res.body as PaginatedLoans;
+          expect(data.length).toBeGreaterThanOrEqual(1);
+          data.forEach(loan => expect(loan.returned_at).toBeNull());
         });
     });
 
@@ -339,9 +378,9 @@ describe('LoansModule (e2e)', (): void => {
         .get('/admin/loans?status=returned')
         .expect(StatusCodes.OK)
         .expect((res: Response) => {
-          const body = res.body as Loan[];
-          expect(body.length).toBeGreaterThanOrEqual(1);
-          body.forEach(loan => expectDateTimeString(loan.returned_at));
+          const { data } = res.body as PaginatedLoans;
+          expect(data.length).toBeGreaterThanOrEqual(1);
+          data.forEach(loan => expectDateTimeString(loan.returned_at));
         });
     });
 
@@ -359,9 +398,9 @@ describe('LoansModule (e2e)', (): void => {
         .get('/admin/loans?status=overdue')
         .expect(StatusCodes.OK)
         .expect((res: Response) => {
-          const body = res.body as Loan[];
-          expect(body.map(loan => loan.id)).toContain(created.id);
-          body.forEach(loan => {
+          const { data } = res.body as PaginatedLoans;
+          expect(data.map(loan => loan.id)).toContain(created.id);
+          data.forEach(loan => {
             expect(loan.returned_at).toBeNull();
             expect(loan.due_date < new Date().toISOString().split('T')[0]).toBe(
               true