12376779843

Committed 17 Dec 2024 04:03PM UTC coverage: 90.153% (+0.06%) from 90.091%

Build # 12376779843

Build Type

Pull #2194

github

Committed by

jmealy

Commit Message

fix: remove .only from tests. Fix test for getting an outreach

Pull Request Pull Request #2194: Allow targeting of all safes for outreach campaigns

Run Details

2826 of 3507 branches covered (80.58%)

Branch coverage included in aggregate %.

18 of 22 new or added lines in 6 files covered. (81.82%)

2 existing lines in 1 file now uncovered.

9634 of 10314 relevant lines covered (93.41%)

434.56 hits per line

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

92.86

/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';
import {
  LoggingService,
  type ILoggingService,
} from '@/logging/logging.interface';

@ApiTags('notifications')
@Controller({ path: '', version: '1' })
export class NotificationsController {
  private isPushNotificationV2Enabled: boolean;
  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,

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

  @ApiOkResponse()
  @Post('register/notifications')
  @HttpCode(200)
  async registerDevice(
    @Body() registerDeviceDto: RegisterDeviceDto,
  ): Promise<void> {
    if (!this.isPushNotificationV2Enabled) {
      return await this.notificationsService.registerDevice(registerDeviceDto);
    }

    // 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.allSettled(unregistrationRequests).then(
        (results: Array<PromiseSettledResult<unknown>>) => {
          for (const result of results) {
            // If the device is not already registered, the TX service will throw a 404 error, but we can safely ignore it.
            if (
              result.status === 'rejected' &&
              'code' in result.reason &&
              result.reason.code !== 404
            ) {
              this.loggingService.error(result.reason);
            }
          }
        },
      );
    }
  }

  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) {
      return await this.unregisterDeviceV2Compatible(chainId, uuid);
    }

    await this.notificationsService.unregisterDevice({ chainId, uuid });
  }

  private async unregisterDeviceV2Compatible(
    chainId: string,
    uuid: UUID,
  ): Promise<void> {
    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.
      const errorObject = error as { code?: number };
      if (errorObject?.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) {
      return this.unregisterSafeV2Compatible(chainId, uuid, safeAddress);
    }

    await this.notificationsService.unregisterSafe({
      chainId,
      uuid,
      safeAddress,
    });
  }

  private async unregisterSafeV2Compatible(
    chainId: string,
    uuid: UUID,
    safeAddress: `0x${string}`,
  ): Promise<void> {
    try {
      // Compatibility with V2
      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.
      const errorObject = error as { code?: number };
      if (errorObject?.code !== 404) {
        throw error;
      }
    }
  }
}

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

safe-global / safe-client-gateway / 12376779843

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