feat: add a delete notifications endpoint

The endpoint allows the deletion of multiple safe push notification subscriptions at once similar to the register endpoint where one can provide multiple safes to subscribe to.

Author: compojoom

src/domain/notifications/v2/entities/__tests__/delete-subscriptions-dto.entity.spec.ts

@@ -0,0 +1,78 @@
+import { deleteSubscriptionsDtoBuilder } from '@/routes/notifications/v2/entities/__tests__/delete-subscriptions.dto.builder';
+import { DeleteSubscriptionsDtoSchema } from '@/domain/notifications/v2/entities/delete-subscriptions.dto.entity';
+import { faker } from '@faker-js/faker';
+import { getAddress } from 'viem';
+
+describe('DeleteSubscriptionsDtoSchema', () => {
+  it('should validate a valid DeleteSubscriptionsDto', () => {
+    const dto = deleteSubscriptionsDtoBuilder().build();
+
+    const result = DeleteSubscriptionsDtoSchema.safeParse(dto);
+
+    expect(result.success).toBe(true);
+  });
+
+  it('should require safes', () => {
+    const dto = deleteSubscriptionsDtoBuilder().build();
+    // @ts-expect-error delete safes
+    delete dto.safes;
+
+    const result = DeleteSubscriptionsDtoSchema.safeParse(dto);
+
+    expect(!result.success && result.error.issues).toStrictEqual([
+      {
+        code: 'invalid_type',
+        expected: 'array',
+        message: 'Required',
+        path: ['safes'],
+        received: 'undefined',
+      },
+    ]);
+  });
+
+  it.each([
+    ['chainId' as const, 'string'],
+    ['address' as const, 'string'],
+  ])('should require safes[number].%s', (key, expected) => {
+    const dto = deleteSubscriptionsDtoBuilder()
+      .with('safes', [
+        {
+          chainId: faker.string.numeric(),
+          address: getAddress(faker.finance.ethereumAddress()),
+        },
+      ])
+      .build();
+    // @ts-expect-error test missing property
+    delete dto.safes[0][key];
+
+    const result = DeleteSubscriptionsDtoSchema.safeParse(dto);
+
+    expect(!result.success && result.error.issues).toStrictEqual([
+      {
+        code: 'invalid_type',
+        expected,
+        message: 'Required',
+        path: ['safes', 0, key],
+        received: 'undefined',
+      },
+    ]);
+  });
+
+  it('should checksum safes[number].address', () => {
+    const nonChecksum = faker.finance.ethereumAddress().toLowerCase();
+    const dto = deleteSubscriptionsDtoBuilder()
+      .with('safes', [
+        {
+          chainId: faker.string.numeric(),
+          address: nonChecksum as `0x${string}`,
+        },
+      ])
+      .build();
+
+    const result = DeleteSubscriptionsDtoSchema.safeParse(dto);
+
+    expect(result.success && result.data.safes[0].address).toBe(
+      getAddress(nonChecksum),
+    );
+  });
+});

src/domain/notifications/v2/entities/delete-subscriptions.dto.entity.ts

@@ -0,0 +1,29 @@
+import { AddressSchema } from '@/validation/entities/schemas/address.schema';
+import { ApiProperty } from '@nestjs/swagger';
+import { z } from 'zod';
+
+export const DeleteSubscriptionsDtoSafesSchema = z.object({
+  chainId: z.string(),
+  address: AddressSchema,
+});
+
+export const DeleteSubscriptionsDtoSchema = z.object({
+  safes: z.array(DeleteSubscriptionsDtoSafesSchema),
+});
+
+export class DeleteSubscriptionsSafesDto
+  implements z.infer<typeof DeleteSubscriptionsDtoSafesSchema>
+{
+  @ApiProperty()
+  chainId!: string;
+
+  @ApiProperty()
+  address!: `0x${string}`;
+}
+
+export class DeleteSubscriptionsDto
+  implements z.infer<typeof DeleteSubscriptionsDtoSchema>
+{
+  @ApiProperty({ type: [DeleteSubscriptionsSafesDto] })
+  safes!: Array<DeleteSubscriptionsSafesDto>;
+}

src/routes/notifications/v2/entities/__tests__/delete-subscriptions.dto.builder.ts

@@ -0,0 +1,15 @@
+import { faker } from '@faker-js/faker';
+import type { IBuilder } from '@/__tests__/builder';
+import { Builder } from '@/__tests__/builder';
+import { getAddress } from 'viem';
+import type { DeleteSubscriptionsDto } from '@/domain/notifications/v2/entities/delete-subscriptions.dto.entity';
+
+export function deleteSubscriptionsDtoBuilder(): IBuilder<DeleteSubscriptionsDto> {
+  return new Builder<DeleteSubscriptionsDto>().with(
+    'safes',
+    Array.from({ length: faker.number.int({ min: 1, max: 5 }) }, () => ({
+      chainId: faker.string.numeric(),
+      address: getAddress(faker.finance.ethereumAddress()),
+    })),
+  );
+}

src/routes/notifications/v2/notifications.controller.spec.ts

@@ -21,6 +21,7 @@ import { safeBuilder } from '@/domain/safe/entities/__tests__/safe.builder';
 import { TestLoggingModule } from '@/logging/__tests__/test.logging.module';
 import { RequestScopedLoggingModule } from '@/logging/logging.module';
 import { upsertSubscriptionsDtoBuilder } from '@/routes/notifications/v2/entities/__tests__/upsert-subscriptions.dto.builder';
+import { deleteSubscriptionsDtoBuilder } from '@/routes/notifications/v2/entities/__tests__/delete-subscriptions.dto.builder';
 import type { Chain } from '@/routes/chains/entities/chain.entity';
 import { faker } from '@faker-js/faker';
 import type { INestApplication } from '@nestjs/common';
@@ -1001,6 +1002,63 @@ describe('Notifications Controller V2 (Unit)', () => {
     });
   });
 
+  describe('DELETE /v2/notifications/devices/:deviceUuid/safes', () => {
+    it('should delete the subscriptions for the provided Safes', async () => {
+      const deviceUuid = faker.string.uuid();
+      const dto = deleteSubscriptionsDtoBuilder().build();
+
+      await request(app.getHttpServer())
+        .delete(`/v2/notifications/devices/${deviceUuid}/safes`)
+        .send(dto)
+        .expect(200);
+
+      expect(notificationsRepository.deleteSubscription).toHaveBeenCalledTimes(
+        dto.safes.length,
+      );
+      for (const [index, safe] of dto.safes.entries()) {
+        expect(notificationsRepository.deleteSubscription).toHaveBeenNthCalledWith(
+          index + 1,
+          {
+            deviceUuid,
+            chainId: safe.chainId,
+            safeAddress: safe.address,
+          },
+        );
+      }
+    });
+
+    it('should return 422 if the deviceUuid is invalid', async () => {
+      const invalidDeviceUuid = faker.string.alphanumeric();
+      const dto = deleteSubscriptionsDtoBuilder().build();
+
+      await request(app.getHttpServer())
+        .delete(`/v2/notifications/devices/${invalidDeviceUuid}/safes`)
+        .send(dto)
+        .expect({
+          statusCode: 422,
+          validation: 'uuid',
+          code: 'invalid_string',
+          message: 'Invalid UUID',
+          path: [],
+        });
+    });
+
+    it('should forward datasource errors', async () => {
+      const deviceUuid = faker.string.uuid();
+      const dto = deleteSubscriptionsDtoBuilder().build();
+      const error = new NotFoundException();
+      notificationsRepository.deleteSubscription.mockRejectedValue(error);
+
+      await request(app.getHttpServer())
+        .delete(`/v2/notifications/devices/${deviceUuid}/safes`)
+        .send(dto)
+        .expect({
+          message: 'Not Found',
+          statusCode: 404,
+        });
+    });
+  });
+
   describe('DELETE /v2/chains/:chainId/notifications/devices/:deviceUuid', () => {
     it('should delete the device', async () => {
       const chainId = faker.string.numeric();

src/routes/notifications/v2/notifications.controller.ts

@@ -2,6 +2,10 @@ import { AuthPayload } from '@/domain/auth/entities/auth-payload.entity';
 import { UpsertSubscriptionsDto } from '@/routes/notifications/v2/entities/upsert-subscriptions.dto.entity';
 import { UpsertSubscriptionsDtoSchema } from '@/domain/notifications/v2/entities/upsert-subscriptions.dto.entity';
 import { NotificationsServiceV2 } from '@/routes/notifications/v2/notifications.service';
+import {
+  DeleteSubscriptionsDto,
+  DeleteSubscriptionsDtoSchema,
+} from '@/domain/notifications/v2/entities/delete-subscriptions.dto.entity';
 import { Auth } from '@/routes/auth/decorators/auth.decorator';
 import { AuthGuard } from '@/routes/auth/guards/auth.guard';
 import { AddressSchema } from '@/validation/entities/schemas/address.schema';
@@ -17,7 +21,7 @@ import {
   Post,
   UseGuards,
 } from '@nestjs/common';
-import { ApiTags } from '@nestjs/swagger';
+import { ApiTags, ApiBody, ApiOperation, ApiParam } from '@nestjs/swagger';
 import { UUID } from 'crypto';
 import { OptionalAuthGuard } from '@/routes/auth/guards/optional-auth.guard';
 import { NotificationType } from '@/datasources/notifications/entities/notification-type.entity.db';
@@ -73,6 +77,32 @@ export class NotificationsControllerV2 {
     });
   }
 
+  @Delete('notifications/devices/:deviceUuid/safes')
+  @ApiOperation({
+    summary: 'Delete notification subscriptions for multiple safes',
+    description:
+      'Deletes notification subscriptions for a list of safes associated with the specified device UUID',
+  })
+  @ApiParam({
+    name: 'deviceUuid',
+    description: 'UUID of the device to delete subscriptions for',
+    type: 'string',
+  })
+  @ApiBody({ type: DeleteSubscriptionsDto })
+  deleteSubscriptions(
+    @Param('deviceUuid', new ValidationPipe(UuidSchema)) deviceUuid: UUID,
+    @Body(new ValidationPipe(DeleteSubscriptionsDtoSchema))
+    deleteSubscriptionsDto: DeleteSubscriptionsDto,
+  ): Promise<void> {
+    return this.notificationsService.deleteSubscriptions({
+      deviceUuid,
+      safes: deleteSubscriptionsDto.safes.map((safe) => ({
+        chainId: safe.chainId,
+        safeAddress: safe.address,
+      })),
+    });
+  }
+
   @Delete('chains/:chainId/notifications/devices/:deviceUuid')
   deleteDevice(
     @Param('chainId', new ValidationPipe(NumericStringSchema)) _chainId: string,

src/routes/notifications/v2/notifications.service.ts

@@ -38,6 +38,19 @@ export class NotificationsServiceV2 {
     await this.notificationsRepository.deleteSubscription(args);
   }
 
+  async deleteSubscriptions(args: {
+    deviceUuid: UUID;
+    safes: Array<{ chainId: string; safeAddress: `0x${string}` }>;
+  }): Promise<void> {
+    for (const safe of args.safes) {
+      await this.notificationsRepository.deleteSubscription({
+        deviceUuid: args.deviceUuid,
+        chainId: safe.chainId,
+        safeAddress: safe.safeAddress,
+      });
+    }
+  }
+
   async deleteDevice(deviceUuid: UUID): Promise<void> {
     await this.notificationsRepository.deleteDevice(deviceUuid);
   }