Merge pull request #182 from CollActionteam/feature/paginated-commitments-api

Implement getAllCommitments Query to get paginated commitments

Author: MichaelSlatteryDev

src/api/rest/commitments/v1/controller/commitment.controller.ts

@@ -1,11 +1,14 @@
-import { Body, Controller, Delete, Param, Patch, Post } from '@nestjs/common';
-import { ApiBody, ApiTags } from '@nestjs/swagger';
+import { Body, Controller, Delete, Get, Param, Patch, Post, Query } from '@nestjs/common';
+import { ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
 import { ICQRSHandler } from '@common/cqrs';
 import { CreateCommitmentCommand, DeleteCommitmentCommand, UpdateCommitmentCommand } from '@modules/commitment';
-import { Identifiable } from '@domain/core';
-import { CreateCommitmentDto, UpdateCommitmentDto } from '@infrastructure/commitment';
+import { Identifiable, IPaginatedList } from '@domain/core';
+import { CreateCommitmentDto, PaginatedCommitmentResponse, UpdateCommitmentDto } from '@infrastructure/commitment';
 import { FirebaseGuard } from '@modules/auth/decorators';
 import { UserRole } from '@domain/auth/enum';
+import { PaginationDto } from '@infrastructure/pagination';
+import { ListCommitmentsQuery } from '@modules/commitment/cqrs/query/list-commitments.query';
+import { ICommitment } from '@domain/commitment';
 
 @Controller('v1/commitments')
 @ApiTags('Commitment')
@@ -31,4 +34,15 @@ export class CommitmentController {
     async updateCommitment(@Param('id') id: string, @Body() updateDto: UpdateCommitmentDto): Promise<Identifiable> {
         return await this.cqrsHandler.execute(UpdateCommitmentCommand, { id, updateDto });
     }
+    @Get()
+    @ApiOperation({ summary: 'Retrieve a paginated list of Commitments' })
+    @ApiResponse({
+        status: 200,
+        description: 'Returns the found Commitments if any',
+        type: PaginatedCommitmentResponse,
+    })
+    @FirebaseGuard(UserRole.MODERATOR, UserRole.ADMIN)
+    async getAllCommitments(@Query() pagination: PaginationDto, @Query('tags') tags: string[]): Promise<IPaginatedList<ICommitment>> {
+        return this.cqrsHandler.fetch(ListCommitmentsQuery, { ...pagination, filter: { tags } });
+    }
 }

src/infrastructure/commitment/dto/commitment.dto.ts

@@ -102,3 +102,19 @@ export class CrowdActionCommitmentDto implements Omit<ICommitment, 'id' | 'creat
     @ApiProperty({ name: 'blocks', required: false })
     readonly blocks?: string[] | undefined;
 }
+export class PaginatedCommitmentResponse {
+    @ApiProperty({ type: [GetCommitmentDto] })
+    readonly items: GetCommitmentDto[];
+
+    @ApiProperty({ example: 1 })
+    readonly page: number;
+
+    @ApiProperty({ example: 10 })
+    readonly pageSize: number;
+
+    @ApiProperty({ example: 1 })
+    readonly totalPages: number;
+
+    @ApiProperty({ example: 1 })
+    readonly totalItems: number;
+}

src/modules/commitment/cqrs/query/list-commitments.query.ts

@@ -0,0 +1,14 @@
+import { Injectable } from '@nestjs/common';
+import { IPaginationQueryArgs, IQuery, paginate } from '@common/cqrs';
+import { FindCriteria } from '@core/repository.interface';
+import { ICommitment, ICommitmentRepository, QueryCommitment } from '@domain/commitment';
+import { IPaginatedList } from '@domain/core';
+
+@Injectable()
+export class ListCommitmentsQuery implements IQuery<IPaginationQueryArgs<FindCriteria<QueryCommitment>>> {
+    constructor(private readonly commitmentRepository: ICommitmentRepository) {}
+
+    async handle(filter: IPaginationQueryArgs<FindCriteria<QueryCommitment>>): Promise<IPaginatedList<ICommitment>> {
+        return paginate(filter, this.commitmentRepository);
+    }
+}

src/modules/commitment/cqrs/tests/list-commitments-query.spec.ts

@@ -0,0 +1,64 @@
+import { connect, Connection, Model } from 'mongoose';
+import { getModelToken } from '@nestjs/mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { Test } from '@nestjs/testing';
+import { ListCommitmentsQuery } from '@modules/commitment/cqrs/query/list-commitments.query';
+import { CommitmentPersistence, CommitmentRepository, CommitmentSchema } from '@infrastructure/mongo';
+import { CQRSHandler, CQRSModule, ICQRSHandler } from '@common/cqrs';
+import { CreateCommitmentStub } from '@modules/commitment/cqrs/tests/create-commitment.command.spec';
+import { CreateCommitmentCommand } from '@modules/commitment';
+import { ICommitmentRepository } from '@domain/commitment';
+
+describe('ListCommitmentsQuery', () => {
+    let listCommitmentsQuery: ListCommitmentsQuery;
+    let commitmentCommand: CreateCommitmentCommand;
+    let CommitmentModel: Model<CommitmentPersistence>;
+    let mongod: MongoMemoryServer;
+    let mongoConnection: Connection;
+    beforeAll(async () => {
+        mongod = await MongoMemoryServer.create();
+        const uri = mongod.getUri();
+        mongoConnection = (await connect(uri)).connection;
+        CommitmentModel = mongoConnection.model(CommitmentPersistence.name, CommitmentSchema);
+        const moduleRef = await Test.createTestingModule({
+            imports: [CQRSModule],
+            providers: [
+                ListCommitmentsQuery,
+                CreateCommitmentCommand,
+                { provide: ICQRSHandler, useClass: CQRSHandler },
+                { provide: ICommitmentRepository, useClass: CommitmentRepository },
+                { provide: getModelToken(CommitmentPersistence.name), useValue: CommitmentModel },
+            ],
+        }).compile();
+        listCommitmentsQuery = moduleRef.get<ListCommitmentsQuery>(ListCommitmentsQuery);
+        commitmentCommand = moduleRef.get<CreateCommitmentCommand>(CreateCommitmentCommand);
+    });
+    afterAll(async () => {
+        await mongoConnection.dropDatabase();
+        await mongoConnection.close();
+        await mongod.stop();
+    });
+    afterEach(async () => {
+        const collections = mongoConnection.collections;
+        for (const key in collections) {
+            const collection = collections[key];
+            await collection.deleteMany({});
+        }
+    });
+    describe('getAllCommitmentsQuery', () => {
+        it('should find all  commitments', async () => {
+            const commitment = CreateCommitmentStub();
+            await commitmentCommand.execute(commitment);
+            const result = await listCommitmentsQuery.handle({
+                filter: { tags: ['FOOD'] },
+                page: 1,
+                pageSize: 1,
+            });
+            expect(result).toBeDefined();
+            expect(result?.items?.length).toEqual(1);
+            expect(result?.pageInfo?.pageSize).toEqual(1);
+            expect(result?.pageInfo?.totalPages).toEqual(1);
+            expect(result?.pageInfo?.totalItems).toEqual(1);
+        });
+    });
+});