12159284351

Committed 04 Dec 2024 12:00PM UTC coverage: 89.901% (-0.07%) from 89.972%

Build # 12159284351

Build Type

Pull #2173

github

Committed by

PooyaRaki

Commit Message

Refactor notification controller error handling

Pull Request Pull Request #2173: Remove old Notification tokens

Run Details

2788 of 3475 branches covered (80.23%)

Branch coverage included in aggregate %.

17 of 30 new or added lines in 2 files covered. (56.67%)

2 existing lines in 1 file now uncovered.

9577 of 10279 relevant lines covered (93.17%)

426.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

48.45

/src/routes/notifications/v1/notifications.controller.ts

import {
  Body,
  Controller,
  Delete,
  HttpCode,
  Inject,
  NotFoundException,
  Param,
  Post,
} from '@nestjs/common';
import { ApiOkResponse, ApiTags } from '@nestjs/swagger';
import { RegisterDeviceDto } from '@/routes/notifications/v1/entities/register-device.dto.entity';
import { NotificationsService } from '@/routes/notifications/v1/notifications.service';
import { ValidationPipe } from '@/validation/pipes/validation.pipe';
import { AddressSchema } from '@/validation/entities/schemas/address.schema';
import type { UpsertSubscriptionsSafesDto } from '@/routes/notifications/v2/entities/upsert-subscriptions.dto.entity';
import { AuthPayload } from '@/domain/auth/entities/auth-payload.entity';
import { NotificationType } from '@/domain/notifications/v2/entities/notification.entity';
import type { UUID } from 'crypto';
import { NotificationsServiceV2 } from '@/routes/notifications/v2/notifications.service';
import { recoverMessageAddress } from 'viem';
import { UuidSchema } from '@/validation/entities/schemas/uuid.schema';
import { IConfigurationService } from '@/config/configuration.service.interface';

@ApiTags('notifications')
@Controller({ path: '', version: '1' })
export class NotificationsController {
  private isPushNotificationV2Enabled = false;
  constructor(
    // Adding NotificationServiceV2 to ensure compatibility with V1.
    // @TODO Remove NotificationModuleV2 after all clients have migrated and compatibility is no longer needed.
    @Inject(NotificationsServiceV2)
    private readonly notificationServiceV2: NotificationsServiceV2,
    private readonly notificationsService: NotificationsService,

    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
  ) {
    this.isPushNotificationV2Enabled =
      this.configurationService.getOrThrow<boolean>(
        'features.pushNotifications',
      );
  }

  @ApiOkResponse()
  @Post('register/notifications')
  @HttpCode(200)
  async registerDevice(
    @Body() registerDeviceDto: RegisterDeviceDto,
  ): Promise<void> {
    if (this.isPushNotificationV2Enabled) {
      // Compatibility with V2
      const compatibleV2Requests =
        await this.createV2RegisterDto(registerDeviceDto);

      const v2Requests = [];

      for (const compatibleV2Request of compatibleV2Requests) {
        v2Requests.push(
          await this.notificationServiceV2.upsertSubscriptions(
            compatibleV2Request,
          ),
        );
      }
      await Promise.all(v2Requests);

      // Remove tokens from the old service to prevent duplication.
      if (registerDeviceDto.uuid) {
        const unregistrationRequests = [];
        for (const safeRegistration of registerDeviceDto.safeRegistrations) {
          unregistrationRequests.push(
            this.notificationsService.unregisterDevice({
              chainId: safeRegistration.chainId,
              uuid: registerDeviceDto.uuid,
            }),
          );
        }
        await Promise.all(unregistrationRequests).catch(() => {}); // If the device is not already registered, the TX service will throw a 404 error, but we can safely ignore it.
      }
    } else {
      await this.notificationsService.registerDevice(registerDeviceDto);
    }
  }

  private async createV2RegisterDto(
    args: RegisterDeviceDto,
  ): Promise<
    Array<Parameters<NotificationsServiceV2['upsertSubscriptions']>[0]>
  > {
    const safeV2Array: Array<
      Parameters<NotificationsServiceV2['upsertSubscriptions']>[0] & {
        upsertSubscriptionsDto: {
          safes: Array<UpsertSubscriptionsSafesDto>;
          signature: `0x${string}`;
        };
      }
    > = [];

    const safesV1Registrations = args.safeRegistrations;

    for (const safeV1Registration of safesV1Registrations) {
      if (safeV1Registration.safes.length) {
        const safeV2: Parameters<
          NotificationsServiceV2['upsertSubscriptions']
        >[0] & {
          upsertSubscriptionsDto: {
            safes: Array<UpsertSubscriptionsSafesDto>;
            signature: `0x${string}`;
          };
        } = {
          upsertSubscriptionsDto: {
            cloudMessagingToken: args.cloudMessagingToken,
            deviceType: args.deviceType,
            deviceUuid: (args.uuid as UUID) || undefined,
            safes: [],
            signature: safeV1Registration.signatures[0] as `0x${string}`,
          },
          authPayload: new AuthPayload(),
        };
        const uniqueSafeAddresses = new Set(safeV1Registration.safes);
        for (const safeAddresses of uniqueSafeAddresses) {
          safeV2.upsertSubscriptionsDto.safes.push({
            address: safeAddresses as `0x${string}`,
            chainId: safeV1Registration.chainId,
            notificationTypes: Object.values(NotificationType),
          });
        }
        safeV2Array.push(safeV2);
      }
    }

    for (const [index, safeV2] of safeV2Array.entries()) {
      const safeAddresses = safeV2.upsertSubscriptionsDto.safes.map(
        (safeV2Safes) => safeV2Safes.address,
      );

      const recoveredAddress = await recoverMessageAddress({
        message: `gnosis-safe${args.timestamp}${args.uuid}${args.cloudMessagingToken}${safeAddresses.sort().join('')}`,
        signature: safeV2.upsertSubscriptionsDto.signature,
      });

      safeV2.authPayload.chain_id =
        safeV2.upsertSubscriptionsDto.safes[0].chainId;
      safeV2.authPayload.signer_address = recoveredAddress;

      safeV2Array[index].authPayload = safeV2.authPayload;
    }

    return safeV2Array;
  }

  @Delete('chains/:chainId/notifications/devices/:uuid')
  async unregisterDevice(
    @Param('chainId') chainId: string,
    @Param('uuid', new ValidationPipe(UuidSchema)) uuid: UUID,
  ): Promise<void> {
    if (this.isPushNotificationV2Enabled) {
      // Compatibility with V2
      try {
        await this.notificationServiceV2.deleteDevice(uuid);
      } catch (error: unknown) {
        if (error instanceof NotFoundException) {
          // Do not throw a NotFound error when attempting to remove the token from the CGW,
          // This ensures the TX service remove method is called
        } else {
          throw error;
        }
      }
    }

    try {
      await this.notificationsService.unregisterDevice({ chainId, uuid });
    } catch (error: unknown) {
      // The token might already have been removed from the TX service.
      // If this happens, the TX service will throw a 404 error, but it is safe to ignore it.
      if (error instanceof Error) {
        if ('code' in error && error.code !== 404) {
          throw error;
        }
      }
    }
  }

  @Delete('chains/:chainId/notifications/devices/:uuid/safes/:safeAddress')
  async unregisterSafe(
    @Param('chainId') chainId: string,
    @Param('uuid', new ValidationPipe(UuidSchema)) uuid: UUID,
    @Param('safeAddress', new ValidationPipe(AddressSchema))
    safeAddress: `0x${string}`,
  ): Promise<void> {
    if (this.isPushNotificationV2Enabled) {
      try {
        // Compatibility with V2
        // @TODO Remove NotificationModuleV2 after all clients have migrated and compatibility is no longer needed.
        await this.notificationServiceV2.deleteSubscription({
          deviceUuid: uuid,
          chainId: chainId,
          safeAddress: safeAddress,
        });
      } catch (error: unknown) {
        if (error instanceof NotFoundException) {
          // Do not throw a NotFound error when attempting to remove the token from the CGW,
          // This ensures the TX service remove method is called
        } else {
          throw error;
        }
      }
    }

    try {
      await this.notificationsService.unregisterSafe({
        chainId,
        uuid,
        safeAddress,
      });
    } catch (error: unknown) {
      // The token might already have been removed from the TX service.
      // If this happens, the TX service will throw a 404 error, but it is safe to ignore it.
      if (error instanceof Error) {
        if ('code' in error && error.code !== 404) {
          throw error;
        }
      }
    }
  }
}

1	import {	108✔
2	Body,
3	Controller,
4	Delete,
5	HttpCode,
6	Inject,
7	NotFoundException,
8	Param,
9	Post,
10	} from '@nestjs/common';
11	import { ApiOkResponse, ApiTags } from '@nestjs/swagger';	108✔
12	import { RegisterDeviceDto } from '@/routes/notifications/v1/entities/register-device.dto.entity';	108✔
13	import { NotificationsService } from '@/routes/notifications/v1/notifications.service';	108✔
14	import { ValidationPipe } from '@/validation/pipes/validation.pipe';	108✔
15	import { AddressSchema } from '@/validation/entities/schemas/address.schema';	108✔
16	import type { UpsertSubscriptionsSafesDto } from '@/routes/notifications/v2/entities/upsert-subscriptions.dto.entity';
17	import { AuthPayload } from '@/domain/auth/entities/auth-payload.entity';	108✔
18	import { NotificationType } from '@/domain/notifications/v2/entities/notification.entity';	108✔
19	import type { UUID } from 'crypto';
20	import { NotificationsServiceV2 } from '@/routes/notifications/v2/notifications.service';	108✔
21	import { recoverMessageAddress } from 'viem';	108✔
22	import { UuidSchema } from '@/validation/entities/schemas/uuid.schema';	108✔
23	import { IConfigurationService } from '@/config/configuration.service.interface';	108✔
24
25	@ApiTags('notifications')
26	@Controller({ path: '', version: '1' })
27	export class NotificationsController {	108✔
28	private isPushNotificationV2Enabled = false;	1,224✔
29	constructor(
30	// Adding NotificationServiceV2 to ensure compatibility with V1.
31	// @TODO Remove NotificationModuleV2 after all clients have migrated and compatibility is no longer needed.
32	@Inject(NotificationsServiceV2)
33	private readonly notificationServiceV2: NotificationsServiceV2,	1,224✔
34	private readonly notificationsService: NotificationsService,	1,224✔
35
36	@Inject(IConfigurationService)
37	private readonly configurationService: IConfigurationService,	1,224✔
38	) {
39	this.isPushNotificationV2Enabled =	1,224✔
40	this.configurationService.getOrThrow<boolean>(
41	'features.pushNotifications',
42	);
43	}
44
45	@ApiOkResponse()
46	@Post('register/notifications')
47	@HttpCode(200)
48	async registerDevice(	108✔
49	@Body() registerDeviceDto: RegisterDeviceDto,
50	): Promise<void> {
51	if (this.isPushNotificationV2Enabled) {	12!
52	// Compatibility with V2
53	const compatibleV2Requests =
UNCOV 54	await this.createV2RegisterDto(registerDeviceDto);	×
55
56	const v2Requests = [];	×
57
58	for (const compatibleV2Request of compatibleV2Requests) {	×
59	v2Requests.push(	×
60	await this.notificationServiceV2.upsertSubscriptions(
61	compatibleV2Request,
62	),
63	);
64	}
UNCOV 65	await Promise.all(v2Requests);	×
66
67	// Remove tokens from the old service to prevent duplication.
NEW 68	if (registerDeviceDto.uuid) {	×
NEW 69	const unregistrationRequests = [];	×
NEW 70	for (const safeRegistration of registerDeviceDto.safeRegistrations) {	×
NEW 71	unregistrationRequests.push(	×
72	this.notificationsService.unregisterDevice({
73	chainId: safeRegistration.chainId,
74	uuid: registerDeviceDto.uuid,
75	}),
76	);
77	}
NEW 78	await Promise.all(unregistrationRequests).catch(() => {}); // If the device is not already registered, the TX service will throw a 404 error, but we can safely ignore it.	×
79	}
80	} else {
81	await this.notificationsService.registerDevice(registerDeviceDto);	12✔
82	}
83	}
84
85	private async createV2RegisterDto(
86	args: RegisterDeviceDto,
87	): Promise<
88	Array<Parameters<NotificationsServiceV2['upsertSubscriptions']>[0]>
89	> {
90	const safeV2Array: Array<
91	Parameters<NotificationsServiceV2['upsertSubscriptions']>[0] & {
92	upsertSubscriptionsDto: {
93	safes: Array<UpsertSubscriptionsSafesDto>;
94	signature: `0x${string}`;
95	};
96	}
97	> = [];	×
98
99	const safesV1Registrations = args.safeRegistrations;	×
100
101	for (const safeV1Registration of safesV1Registrations) {	×
102	if (safeV1Registration.safes.length) {	×
103	const safeV2: Parameters<
104	NotificationsServiceV2['upsertSubscriptions']
105	>[0] & {
106	upsertSubscriptionsDto: {
107	safes: Array<UpsertSubscriptionsSafesDto>;
108	signature: `0x${string}`;
109	};
110	} = {	×
111	upsertSubscriptionsDto: {
112	cloudMessagingToken: args.cloudMessagingToken,
113	deviceType: args.deviceType,
114	deviceUuid: (args.uuid as UUID) \|\| undefined,	×
115	safes: [],
116	signature: safeV1Registration.signatures[0] as `0x${string}`,
117	},
118	authPayload: new AuthPayload(),
119	};
120	const uniqueSafeAddresses = new Set(safeV1Registration.safes);	×
121	for (const safeAddresses of uniqueSafeAddresses) {	×
122	safeV2.upsertSubscriptionsDto.safes.push({	×
123	address: safeAddresses as `0x${string}`,
124	chainId: safeV1Registration.chainId,
125	notificationTypes: Object.values(NotificationType),
126	});
127	}
128	safeV2Array.push(safeV2);	×
129	}
130	}
131
132	for (const [index, safeV2] of safeV2Array.entries()) {	×
133	const safeAddresses = safeV2.upsertSubscriptionsDto.safes.map(	×
134	(safeV2Safes) => safeV2Safes.address,	×
135	);
136
137	const recoveredAddress = await recoverMessageAddress({	×
138	message: `gnosis-safe${args.timestamp}${args.uuid}${args.cloudMessagingToken}${safeAddresses.sort().join('')}`,
139	signature: safeV2.upsertSubscriptionsDto.signature,
140	});
141
142	safeV2.authPayload.chain_id =	×
143	safeV2.upsertSubscriptionsDto.safes[0].chainId;
144	safeV2.authPayload.signer_address = recoveredAddress;	×
145
146	safeV2Array[index].authPayload = safeV2.authPayload;	×
147	}
148
149	return safeV2Array;	×
150	}
151
152	@Delete('chains/:chainId/notifications/devices/:uuid')
153	async unregisterDevice(	108✔
154	@Param('chainId') chainId: string,
155	@Param('uuid', new ValidationPipe(UuidSchema)) uuid: UUID,
156	): Promise<void> {
157	if (this.isPushNotificationV2Enabled) {	6!
158	// Compatibility with V2
NEW 159	try {	×
NEW 160	await this.notificationServiceV2.deleteDevice(uuid);	×
161	} catch (error: unknown) {
NEW 162	if (error instanceof NotFoundException) {	×
163	// Do not throw a NotFound error when attempting to remove the token from the CGW,
164	// This ensures the TX service remove method is called
165	} else {
NEW 166	throw error;	×
167	}
168	}
169	}
170
171	try {	6✔
172	await this.notificationsService.unregisterDevice({ chainId, uuid });	6✔
173	} catch (error: unknown) {
174	// The token might already have been removed from the TX service.
175	// If this happens, the TX service will throw a 404 error, but it is safe to ignore it.
176	if (error instanceof Error) {	4✔
177	if ('code' in error && error.code !== 404) {	4✔
178	throw error;	4✔
179	}
180	}
181	}
182	}
183
184	@Delete('chains/:chainId/notifications/devices/:uuid/safes/:safeAddress')
185	async unregisterSafe(	108✔
186	@Param('chainId') chainId: string,
187	@Param('uuid', new ValidationPipe(UuidSchema)) uuid: UUID,
188	@Param('safeAddress', new ValidationPipe(AddressSchema))
189	safeAddress: `0x${string}`,
190	): Promise<void> {
191	if (this.isPushNotificationV2Enabled) {	6!
NEW 192	try {	×
193	// Compatibility with V2
194	// @TODO Remove NotificationModuleV2 after all clients have migrated and compatibility is no longer needed.
NEW 195	await this.notificationServiceV2.deleteSubscription({	×
196	deviceUuid: uuid,
197	chainId: chainId,
198	safeAddress: safeAddress,
199	});
200	} catch (error: unknown) {
NEW 201	if (error instanceof NotFoundException) {	×
202	// Do not throw a NotFound error when attempting to remove the token from the CGW,
203	// This ensures the TX service remove method is called
204	} else {
NEW 205	throw error;	×
206	}
207	}
208	}
209
210	try {	6✔
211	await this.notificationsService.unregisterSafe({	6✔
212	chainId,
213	uuid,
214	safeAddress,
215	});
216	} catch (error: unknown) {
217	// The token might already have been removed from the TX service.
218	// If this happens, the TX service will throw a 404 error, but it is safe to ignore it.
219	if (error instanceof Error) {	4✔
220	if ('code' in error && error.code !== 404) {	4✔
221	throw error;	4✔
222	}
223	}
224	}
225	}
226	}

safe-global / safe-client-gateway / 12159284351

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous