Add campaigns routes (safe-global#1551)

hectorgomezv · web-flow · commit e90c46fdbdb1 · 2024-05-16T11:01:07.000+02:00
Adds the following endpoints to the service:
GET /api/v1/locking/campaigns
GET /api/v1/locking/campaigns/:campaignId
diff --git a/src/domain/locking/entities/__tests__/campaign.builder.ts b/src/domain/locking/entities/__tests__/campaign.builder.ts
@@ -1,4 +1,5 @@
 import { IBuilder, Builder } from '@/__tests__/builder';
+import { activityMetadataBuilder } from '@/domain/locking/entities/__tests__/activity-metadata.builder';
 import { Campaign } from '@/domain/locking/entities/campaign.entity';
 import { faker } from '@faker-js/faker';
 
@@ -9,5 +10,11 @@ export function campaignBuilder(): IBuilder<Campaign> {
     .with('description', faker.lorem.sentence())
     .with('periodStart', faker.date.recent())
     .with('periodEnd', faker.date.future())
-    .with('lastUpdated', faker.date.recent());
+    .with('lastUpdated', faker.date.recent())
+    .with(
+      'activities',
+      Array.from({ length: faker.number.int({ min: 0, max: 5 }) }, () =>
+        activityMetadataBuilder().build(),
+      ),
+    );
 }
diff --git a/src/domain/locking/entities/campaign.entity.ts b/src/domain/locking/entities/campaign.entity.ts
@@ -1,3 +1,4 @@
+import { buildPageSchema } from '@/domain/entities/schemas/page.schema.factory';
 import { ActivityMetadataSchema } from '@/domain/locking/entities/activity-metadata.entity';
 import { z } from 'zod';
 
@@ -12,3 +13,5 @@ export const CampaignSchema = z.object({
   lastUpdated: z.coerce.date(),
   activities: z.array(ActivityMetadataSchema).nullish().default(null),
 });
+
+export const CampaignPageSchema = buildPageSchema(CampaignSchema);
diff --git a/src/domain/locking/locking.repository.interface.ts b/src/domain/locking/locking.repository.interface.ts
@@ -1,10 +1,18 @@
 import { Page } from '@/domain/entities/page.entity';
+import { Campaign } from '@/domain/locking/entities/campaign.entity';
 import { LockingEvent } from '@/domain/locking/entities/locking-event.entity';
 import { Rank } from '@/domain/locking/entities/rank.entity';
 
 export const ILockingRepository = Symbol('ILockingRepository');
 
 export interface ILockingRepository {
+  getCampaignById(campaignId: string): Promise<Campaign>;
+
+  getCampaigns(args: {
+    limit?: number;
+    offset?: number;
+  }): Promise<Page<Campaign>>;
+
   getRank(safeAddress: `0x${string}`): Promise<Rank>;
 
   getLeaderboard(args: {
diff --git a/src/domain/locking/locking.repository.ts b/src/domain/locking/locking.repository.ts
@@ -1,5 +1,9 @@
 import { Page } from '@/domain/entities/page.entity';
 import { ILockingApi } from '@/domain/interfaces/locking-api.interface';
+import {
+  Campaign,
+  CampaignPageSchema,
+} from '@/domain/locking/entities/campaign.entity';
 import { LockingEvent } from '@/domain/locking/entities/locking-event.entity';
 import { Rank } from '@/domain/locking/entities/rank.entity';
 import { LockingEventPageSchema } from '@/domain/locking/entities/schemas/locking-event.schema';
@@ -17,6 +21,18 @@ export class LockingRepository implements ILockingRepository {
     private readonly lockingApi: ILockingApi,
   ) {}
 
+  async getCampaignById(campaignId: string): Promise<Campaign> {
+    return this.lockingApi.getCampaignById(campaignId);
+  }
+
+  async getCampaigns(args: {
+    limit?: number | undefined;
+    offset?: number | undefined;
+  }): Promise<Page<Campaign>> {
+    const page = await this.lockingApi.getCampaigns(args);
+    return CampaignPageSchema.parse(page);
+  }
+
   async getRank(safeAddress: `0x${string}`): Promise<Rank> {
     const rank = await this.lockingApi.getRank(safeAddress);
     return RankSchema.parse(rank);
diff --git a/src/routes/locking/entities/activity-metadata.entity.ts b/src/routes/locking/entities/activity-metadata.entity.ts
@@ -0,0 +1,13 @@
+import { ActivityMetadata as DomainActivityMetadata } from '@/domain/locking/entities/activity-metadata.entity';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class ActivityMetadata implements DomainActivityMetadata {
+  @ApiProperty()
+  campaignId!: string;
+  @ApiProperty()
+  name!: string;
+  @ApiProperty()
+  description!: string;
+  @ApiProperty()
+  maxPoints!: string;
+}
diff --git a/src/routes/locking/entities/campaign.entity.ts b/src/routes/locking/entities/campaign.entity.ts
@@ -0,0 +1,20 @@
+import { Campaign as DomainCampaign } from '@/domain/locking/entities/campaign.entity';
+import { ActivityMetadata } from '@/routes/locking/entities/activity-metadata.entity';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class Campaign implements DomainCampaign {
+  @ApiProperty()
+  campaignId!: string;
+  @ApiProperty()
+  name!: string;
+  @ApiProperty()
+  description!: string;
+  @ApiProperty({ type: String })
+  periodStart!: Date;
+  @ApiProperty({ type: String })
+  periodEnd!: Date;
+  @ApiProperty({ type: String })
+  lastUpdated!: Date;
+  @ApiProperty({ type: [ActivityMetadata] })
+  activities!: ActivityMetadata[] | null;
+}
diff --git a/src/routes/locking/entities/campaign.page.entity.ts b/src/routes/locking/entities/campaign.page.entity.ts
@@ -0,0 +1,8 @@
+import { Page } from '@/routes/common/entities/page.entity';
+import { Campaign } from '@/routes/locking/entities/campaign.entity';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class CampaignPage extends Page<Campaign> {
+  @ApiProperty({ type: [Campaign] })
+  results!: Array<Campaign>;
+}
diff --git a/src/routes/locking/locking.controller.spec.ts b/src/routes/locking/locking.controller.spec.ts
@@ -31,6 +31,8 @@ import { rankBuilder } from '@/domain/locking/entities/__tests__/rank.builder';
 import { PaginationData } from '@/routes/common/pagination/pagination.data';
 import { TestQueuesApiModule } from '@/datasources/queues/__tests__/test.queues-api.module';
 import { QueuesApiModule } from '@/datasources/queues/queues-api.module';
+import { campaignBuilder } from '@/domain/locking/entities/__tests__/campaign.builder';
+import { Campaign } from '@/domain/locking/entities/campaign.entity';
 
 describe('Locking (Unit)', () => {
   let app: INestApplication;
@@ -67,6 +69,165 @@ describe('Locking (Unit)', () => {
     await app.close();
   });
 
+  describe('GET campaign', () => {
+    it('should get the campaign', async () => {
+      const campaign = campaignBuilder().build();
+      networkService.get.mockImplementation(({ url }) => {
+        switch (url) {
+          case `${lockingBaseUri}/api/v1/campaigns/${campaign.campaignId}`:
+            return Promise.resolve({ data: campaign, status: 200 });
+          default:
+            return Promise.reject(`No matching rule for url: ${url}`);
+        }
+      });
+
+      await request(app.getHttpServer())
+        .get(`/v1/locking/campaigns/${campaign.campaignId}`)
+        .expect(200)
+        .expect({
+          ...campaign,
+          periodStart: campaign.periodStart.toISOString(),
+          periodEnd: campaign.periodEnd.toISOString(),
+          lastUpdated: campaign.lastUpdated.toISOString(),
+        });
+    });
+
+    it('should get the list of campaigns', async () => {
+      const campaignsPage = pageBuilder<Campaign>()
+        .with('results', [campaignBuilder().build()])
+        .with('count', 1)
+        .with('previous', null)
+        .with('next', null)
+        .build();
+      networkService.get.mockImplementation(({ url }) => {
+        switch (url) {
+          case `${lockingBaseUri}/api/v1/campaigns`:
+            return Promise.resolve({ data: campaignsPage, status: 200 });
+          default:
+            return Promise.reject(`No matching rule for url: ${url}`);
+        }
+      });
+
+      await request(app.getHttpServer())
+        .get(`/v1/locking/campaigns`)
+        .expect(200)
+        .expect({
+          count: 1,
+          next: null,
+          previous: null,
+          results: campaignsPage.results.map((campaign) => ({
+            ...campaign,
+            periodStart: campaign.periodStart.toISOString(),
+            periodEnd: campaign.periodEnd.toISOString(),
+            lastUpdated: campaign.lastUpdated.toISOString(),
+          })),
+        });
+    });
+
+    it('should validate the list of campaigns', async () => {
+      const invalidCampaigns = [{ invalid: 'campaign' }];
+      const campaignsPage = pageBuilder()
+        .with('results', invalidCampaigns)
+        .with('count', 1)
+        .with('previous', null)
+        .with('next', null)
+        .build();
+      networkService.get.mockImplementation(({ url }) => {
+        switch (url) {
+          case `${lockingBaseUri}/api/v1/campaigns`:
+            return Promise.resolve({ data: campaignsPage, status: 200 });
+          default:
+            return Promise.reject(`No matching rule for url: ${url}`);
+        }
+      });
+
+      await request(app.getHttpServer())
+        .get(`/v1/locking/campaigns`)
+        .expect(500)
+        .expect({
+          statusCode: 500,
+          message: 'Internal server error',
+        });
+    });
+
+    it('should forward the pagination parameters', async () => {
+      const limit = faker.number.int({ min: 1, max: 10 });
+      const offset = faker.number.int({ min: 1, max: 10 });
+      const campaignsPage = pageBuilder<Campaign>()
+        .with('results', [campaignBuilder().build()])
+        .with('count', 1)
+        .with('previous', null)
+        .with('next', null)
+        .build();
+      networkService.get.mockImplementation(({ url }) => {
+        switch (url) {
+          case `${lockingBaseUri}/api/v1/campaigns`:
+            return Promise.resolve({ data: campaignsPage, status: 200 });
+          default:
+            return Promise.reject(`No matching rule for url: ${url}`);
+        }
+      });
+
+      await request(app.getHttpServer())
+        .get(
+          `/v1/locking/campaigns?cursor=limit%3D${limit}%26offset%3D${offset}`,
+        )
+        .expect(200)
+        .expect({
+          count: 1,
+          next: null,
+          previous: null,
+          results: campaignsPage.results.map((campaign) => ({
+            ...campaign,
+            periodStart: campaign.periodStart.toISOString(),
+            periodEnd: campaign.periodEnd.toISOString(),
+            lastUpdated: campaign.lastUpdated.toISOString(),
+          })),
+        });
+
+      expect(networkService.get).toHaveBeenCalledWith({
+        url: `${lockingBaseUri}/api/v1/campaigns`,
+        networkRequest: {
+          params: {
+            limit,
+            offset,
+          },
+        },
+      });
+    });
+
+    it('should forward errors from the service', async () => {
+      const statusCode = faker.internet.httpStatusCode({
+        types: ['clientError', 'serverError'],
+      });
+      const errorMessage = faker.word.words();
+      networkService.get.mockImplementation(({ url }) => {
+        switch (url) {
+          case `${lockingBaseUri}/api/v1/campaigns`:
+            return Promise.reject(
+              new NetworkResponseError(
+                new URL(`${lockingBaseUri}/api/v1/campaigns`),
+                {
+                  status: statusCode,
+                } as Response,
+                { message: errorMessage, status: statusCode },
+              ),
+            );
+          default:
+            return Promise.reject(`No matching rule for url: ${url}`);
+        }
+      });
+
+      await request(app.getHttpServer())
+        .get(`/v1/locking/campaigns`)
+        .expect(statusCode)
+        .expect({
+          message: errorMessage,
+          code: statusCode,
+        });
+    });
+  });
+
   describe('GET rank', () => {
     it('should get the rank', async () => {
       const rank = rankBuilder().build();
diff --git a/src/routes/locking/locking.controller.ts b/src/routes/locking/locking.controller.ts
@@ -9,6 +9,8 @@ import { AddressSchema } from '@/validation/entities/schemas/address.schema';
 import { ValidationPipe } from '@/validation/pipes/validation.pipe';
 import { Controller, Get, Param } from '@nestjs/common';
 import { ApiOkResponse, ApiQuery, ApiTags } from '@nestjs/swagger';
+import { Campaign } from '@/routes/locking/entities/campaign.entity';
+import { CampaignPage } from '@/routes/locking/entities/campaign.page.entity';
 
 @ApiTags('locking')
 @Controller({
@@ -18,6 +20,28 @@ import { ApiOkResponse, ApiQuery, ApiTags } from '@nestjs/swagger';
 export class LockingController {
   constructor(private readonly lockingService: LockingService) {}
 
+  @ApiOkResponse({ type: Campaign })
+  @Get('/campaigns/:campaignId')
+  async getCampaignById(
+    @Param('campaignId') campaignId: string,
+  ): Promise<Campaign> {
+    return this.lockingService.getCampaignById(campaignId);
+  }
+
+  @ApiOkResponse({ type: CampaignPage })
+  @ApiQuery({
+    name: 'cursor',
+    required: false,
+    type: String,
+  })
+  @Get('/campaigns')
+  async getCampaigns(
+    @RouteUrlDecorator() routeUrl: URL,
+    @PaginationDataDecorator() paginationData: PaginationData,
+  ): Promise<CampaignPage> {
+    return this.lockingService.getCampaigns({ routeUrl, paginationData });
+  }
+
   @ApiOkResponse({ type: Rank })
   @Get('/leaderboard/rank/:safeAddress')
   async getRank(
diff --git a/src/routes/locking/locking.service.ts b/src/routes/locking/locking.service.ts
@@ -1,4 +1,5 @@
 import { Page } from '@/domain/entities/page.entity';
+import { Campaign } from '@/domain/locking/entities/campaign.entity';
 import { LockingEvent } from '@/domain/locking/entities/locking-event.entity';
 import { Rank } from '@/domain/locking/entities/rank.entity';
 import { ILockingRepository } from '@/domain/locking/locking.repository.interface';
@@ -15,6 +16,32 @@ export class LockingService {
     private readonly lockingRepository: ILockingRepository,
   ) {}
 
+  async getCampaignById(campaignId: string): Promise<Campaign> {
+    return this.lockingRepository.getCampaignById(campaignId);
+  }
+
+  async getCampaigns(args: {
+    routeUrl: URL;
+    paginationData: PaginationData;
+  }): Promise<Page<Campaign>> {
+    const result = await this.lockingRepository.getCampaigns(
+      args.paginationData,
+    );
+
+    const nextUrl = cursorUrlFromLimitAndOffset(args.routeUrl, result.next);
+    const previousUrl = cursorUrlFromLimitAndOffset(
+      args.routeUrl,
+      result.previous,
+    );
+
+    return {
+      count: result.count,
+      next: nextUrl?.toString() ?? null,
+      previous: previousUrl?.toString() ?? null,
+      results: result.results,
+    };
+  }
+
   async getRank(safeAddress: `0x${string}`): Promise<Rank> {
     return this.lockingRepository.getRank(safeAddress);
   }
