Remove old Notification tokens (#2173)

This PR ensures that duplicate push notifications are avoided by removing the registered push notification token from the TX service during device registration through the Client Gateway (CGW). This prevents multiple registrations from causing redundant notifications.

src/domain/notifications/v2/notifications.repository.integration.spec.ts

@@ -19,6 +19,7 @@ import { notificationDeviceBuilder } from '@/datasources/notifications/entities/
 import { NotificationType as NotificationTypeEnum } from '@/domain/notifications/v2/entities/notification.entity';
 import { DatabaseMigrator } from '@/datasources/db/v2/database-migrator.service';
 import type { ConfigService } from '@nestjs/config';
+import { NotFoundException } from '@nestjs/common';
 
 describe('NotificationsRepositoryV2', () => {
   const mockLoggingService = {
@@ -527,6 +528,34 @@ describe('NotificationsRepositoryV2', () => {
       expect(subscriptionAfterRemoval).toHaveLength(0);
     });
 
+    it('Should throw NotFoundException if a subscription does not exist', async () => {
+      const authPayloadDto = authPayloadDtoBuilder().build();
+      const authPayload = new AuthPayload(authPayloadDto);
+      const upsertSubscriptionsDto = upsertSubscriptionsDtoBuilder().build();
+
+      const notificationSubscriptionRepository = dataSource.getRepository(
+        NotificationSubscription,
+      );
+      jest.spyOn(notificationSubscriptionRepository, 'remove');
+
+      const subscription = await notificationSubscriptionRepository.findBy({
+        safe_address: upsertSubscriptionsDto.safes[0].address,
+        chain_id: upsertSubscriptionsDto.safes[0].chainId,
+        signer_address: authPayload.signer_address,
+      });
+
+      const result = notificationsRepositoryService.deleteSubscription({
+        deviceUuid: upsertSubscriptionsDto.deviceUuid as UUID,
+        chainId: upsertSubscriptionsDto.safes[0].chainId,
+        safeAddress: upsertSubscriptionsDto.safes[0].address,
+      });
+
+      await expect(result).rejects.toThrow(
+        new NotFoundException('No Subscription Found!'),
+      );
+      expect(subscription).toHaveLength(0);
+    });
+
     it('Should not try to remove if a subscription does not exist', async () => {
       const authPayloadDto = authPayloadDtoBuilder().build();
       const authPayload = new AuthPayload(authPayloadDto);
@@ -543,12 +572,13 @@ describe('NotificationsRepositoryV2', () => {
         signer_address: authPayload.signer_address,
       });
 
-      await notificationsRepositoryService.deleteSubscription({
+      const result = notificationsRepositoryService.deleteSubscription({
         deviceUuid: upsertSubscriptionsDto.deviceUuid as UUID,
         chainId: upsertSubscriptionsDto.safes[0].chainId,
         safeAddress: upsertSubscriptionsDto.safes[0].address,
       });
 
+      await expect(result).rejects.toThrow();
       expect(subscription).toHaveLength(0);
       expect(notificationSubscriptionRepository.remove).not.toHaveBeenCalled();
     });
@@ -573,24 +603,18 @@ describe('NotificationsRepositoryV2', () => {
       expect(findDevice).toBeNull();
     });
 
-    it('Should not throw if a uuid does not exist', async () => {
+    it('Should throw NotFoundException if a uuid does not exist', async () => {
       const deviceDto = notificationDeviceBuilder()
         .with('id', faker.number.int({ min: 1, max: 1999 }))
         .build();
 
-      const notificationDeviceRepository =
-        dataSource.getRepository(NotificationDevice);
-
-      const result = await notificationsRepositoryService.deleteDevice(
+      const result = notificationsRepositoryService.deleteDevice(
         deviceDto.device_uuid,
       );
 
-      const findDevice = await notificationDeviceRepository.findOneBy({
-        device_uuid: deviceDto.device_uuid,
-      });
-
-      expect(findDevice).toBeNull();
-      expect(result).toBeUndefined();
+      await expect(result).rejects.toThrow(
+        new NotFoundException('No Device Found!'),
+      );
     });
 
     it('Should delete a device with its subscription', async () => {

src/domain/notifications/v2/notifications.repository.spec.ts

@@ -1,6 +1,6 @@
 import type { UUID } from 'crypto';
 import { faker } from '@faker-js/faker/.';
-import { UnauthorizedException } from '@nestjs/common';
+import { NotFoundException, UnauthorizedException } from '@nestjs/common';
 import { type ILoggingService } from '@/logging/logging.interface';
 import { AuthPayload } from '@/domain/auth/entities/auth-payload.entity';
 import { NotificationsRepositoryV2 } from '@/domain/notifications/v2/notifications.repository';
@@ -16,6 +16,7 @@ import { NotificationDevice } from '@/datasources/notifications/entities/notific
 import { mockEntityManager } from '@/datasources/db/v2/__tests__/entity-manager.mock';
 import { mockPostgresDatabaseService } from '@/datasources/db/v2/__tests__/postgresql-database.service.mock';
 import { mockRepository } from '@/datasources/db/v2/__tests__/repository.mock';
+import { getAddress } from 'viem';
 
 describe('NotificationsRepositoryV2', () => {
   let notificationsRepository: INotificationsRepositoryV2;
@@ -395,8 +396,9 @@ describe('NotificationsRepositoryV2', () => {
         safeAddress: faker.string.hexadecimal({ length: 32 }) as `0x${string}`,
       };
 
-      await notificationsRepository.deleteSubscription(args);
+      const result = notificationsRepository.deleteSubscription(args);
 
+      await expect(result).rejects.toThrow();
       expect(notificationSubscriptionRepository.findOne).toHaveBeenCalledTimes(
         1,
       );
@@ -411,10 +413,45 @@ describe('NotificationsRepositoryV2', () => {
       });
       expect(notificationSubscriptionRepository.remove).not.toHaveBeenCalled();
     });
+
+    it('Should throw NotFoundException if no subscription is found', async () => {
+      notificationSubscriptionRepository.findOne.mockResolvedValue(null);
+      mockPostgresDatabaseService.getRepository.mockResolvedValue(
+        notificationSubscriptionRepository,
+      );
+
+      const args = {
+        deviceUuid: faker.string.uuid() as UUID,
+        chainId: faker.number.int({ min: 0 }).toString(),
+        safeAddress: getAddress(faker.finance.ethereumAddress()),
+      };
+
+      const result = notificationsRepository.deleteSubscription(args);
+
+      await expect(result).rejects.toThrow(
+        new NotFoundException('No Subscription Found!'),
+      );
+      expect(notificationSubscriptionRepository.findOne).toHaveBeenCalledTimes(
+        1,
+      );
+      expect(notificationSubscriptionRepository.findOne).toHaveBeenCalledWith({
+        where: {
+          chain_id: args.chainId,
+          safe_address: args.safeAddress,
+          push_notification_device: {
+            device_uuid: args.deviceUuid,
+          },
+        },
+      });
+    });
   });
 
   describe('deleteDevice()', () => {
     it('Should delete a device successfully', async () => {
+      notificationDeviceRepository.delete.mockResolvedValue({
+        affected: 1,
+        raw: [],
+      });
       mockPostgresDatabaseService.getRepository.mockResolvedValue(
         notificationDeviceRepository,
       );
@@ -428,5 +465,27 @@ describe('NotificationsRepositoryV2', () => {
         device_uuid: deviceUuid,
       });
     });
+
+    it('Should throw if a device uuid does not exist', async () => {
+      notificationDeviceRepository.delete.mockResolvedValue({
+        affected: 0,
+        raw: [],
+      });
+      mockPostgresDatabaseService.getRepository.mockResolvedValue(
+        notificationDeviceRepository,
+      );
+
+      const deviceUuid = faker.string.uuid() as UUID;
+
+      const result = notificationsRepository.deleteDevice(deviceUuid);
+
+      await expect(result).rejects.toThrow(
+        new NotFoundException('No Device Found!'),
+      );
+      expect(notificationDeviceRepository.delete).toHaveBeenCalled();
+      expect(notificationDeviceRepository.delete).toHaveBeenCalledWith({
+        device_uuid: deviceUuid,
+      });
+    });
   });
 });

src/domain/notifications/v2/notifications.repository.ts

@@ -6,6 +6,7 @@ import type { INotificationsRepositoryV2 } from '@/domain/notifications/v2/notif
 import {
   Inject,
   Injectable,
+  NotFoundException,
   UnauthorizedException,
   UnprocessableEntityException,
 } from '@nestjs/common';
@@ -368,9 +369,11 @@ export class NotificationsRepositoryV2 implements INotificationsRepositoryV2 {
       },
     });
 
-    if (subscription) {
-      await notificationsSubscriptionsRepository.remove(subscription);
+    if (!subscription) {
+      throw new NotFoundException('No Subscription Found!');
     }
+
+    await notificationsSubscriptionsRepository.remove(subscription);
   }
 
   public async deleteDevice(deviceUuid: UUID): Promise<void> {
@@ -379,8 +382,12 @@ export class NotificationsRepositoryV2 implements INotificationsRepositoryV2 {
         NotificationDevice,
       );
 
-    await notificationsDeviceRepository.delete({
+    const deleteResult = await notificationsDeviceRepository.delete({
       device_uuid: deviceUuid,
     });
+
+    if (!deleteResult.affected) {
+      throw new NotFoundException('No Device Found!');
+    }
   }
 }