10166116522

Committed 30 Jul 2024 04:24PM UTC coverage: 47.257% (-1.0%) from 48.264%

Build # 10166116522

Build Type

Pull #1778

github

Committed by

iamacook

Commit Message

Merge branch 'notifications-database' into notifications-domain

Pull Request Pull Request #1778: Add domain logic for push notifications

Run Details

448 of 2771 branches covered (16.17%)

Branch coverage included in aggregate %.

39 of 167 new or added lines in 9 files covered. (23.35%)

49 existing lines in 1 file now uncovered.

4401 of 7490 relevant lines covered (58.76%)

12.72 hits per line

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

25.81

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

import { UpsertSubscriptionsDto } from '@/domain/notifications/entities-v2/upsert-subscriptions.dto.entity';
import { FirebaseNotification } from '@/datasources/push-notifications-api/entities/firebase-notification.entity';
import { INotificationsDatasource } from '@/domain/interfaces/notifications.datasource.interface';
import { IPushNotificationsApi } from '@/domain/interfaces/push-notifications-api.interface';
import { Uuid } from '@/domain/notifications/entities-v2/uuid.entity';
import { INotificationsRepositoryV2 } from '@/domain/notifications/notifications.repository.v2.interface';
import {
  Inject,
  Injectable,
  UnprocessableEntityException,
} from '@nestjs/common';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { NotificationType } from '@/domain/notifications/entities-v2/notification.entity';
import { get } from 'lodash';

@Injectable()
export class NotificationsRepositoryV2 implements INotificationsRepositoryV2 {
  /**
   * Firebase REST error message for the HTTP v1 API relevant to token registration:
   *
   * This error can be caused by missing registration tokens, or unregistered tokens.
   *
   * Missing Registration: If the message's target is a token value, check that the
   * request contains a registration token.
   *
   * Not registered: An existing registration token may cease to be valid in a number
   * of scenarios, including:
   * - If the client app unregisters with FCM.
   * - If the client app is automatically unregistered, which can happen if the user
   *   uninstalls the application. For example, on iOS, if the APNs Feedback Service
   *   reported the APNs token as invalid.
   * - If the registration token expires (for example, Google might decide to refresh
   *   registration tokens, or the APNs token has expired for iOS devices).
   * - If the client app is updated but the new version is not configured to receive
   *   messages.
   *
   * For all these cases, remove this registration token from the app server and stop
   * using it to send messages.
   *
   * @see https://firebase.google.com/docs/cloud-messaging/send-message#rest
   */
  static readonly UnregisteredErrorCode = 404;
  static readonly UnregisteredErrorStatus = 'UNREGISTERED';

  constructor(
    @Inject(IPushNotificationsApi)
    private readonly pushNotificationsApi: IPushNotificationsApi,
    @Inject(INotificationsDatasource)
    private readonly notificationsDatasource: INotificationsDatasource,
    @Inject(LoggingService)
    private readonly loggingService: ILoggingService,
  ) {}

  async enqueueNotification(args: {
    token: string;
    deviceUuid: Uuid;
    notification: FirebaseNotification;
  }): Promise<void> {
    try {
      await this.pushNotificationsApi.enqueueNotification(
        args.token,
        args.notification,
      );
    } catch (e) {
      if (this.isTokenUnregistered(e)) {
        await this.deleteDevice(args.deviceUuid).catch(() => null);
      } else {
        this.loggingService.info(`Failed to enqueue notification: ${e}`);
        throw new UnprocessableEntityException();
      }
    }
  }

  private isTokenUnregistered(error: unknown): boolean {
    const isNotFound =
      get(error, 'code') === NotificationsRepositoryV2.UnregisteredErrorCode;
    const isUnregistered =
      get(error, 'status') ===
      NotificationsRepositoryV2.UnregisteredErrorStatus;
    return isNotFound && isUnregistered;
  }

  async upsertSubscriptions(args: {
    signerAddress: `0x${string}`;
    upsertSubscriptionsDto: UpsertSubscriptionsDto;
  }): Promise<{
    deviceUuid: Uuid;
  }> {
    return this.notificationsDatasource.upsertSubscriptions(args);
  }

  getSafeSubscription(args: {
    deviceUuid: Uuid;
    chainId: string;
    safeAddress: `0x${string}`;
    signerAddress: `0x${string}`;
  }): Promise<Array<NotificationType>> {
    return this.notificationsDatasource.getSafeSubscription(args);
  }

  getSubscribersBySafe(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): Promise<
    Array<{
      subscriber: `0x${string}`;
      deviceUuid: Uuid;
      cloudMessagingToken: string;
    }>
  > {
    return this.notificationsDatasource.getSubscribersBySafe(args);
  }

  deleteSubscription(args: {
    deviceUuid: Uuid;
    chainId: string;
    safeAddress: `0x${string}`;
    signerAddress: `0x${string}`;
  }): Promise<void> {
    return this.notificationsDatasource.deleteSubscription(args);
  }

  deleteDevice(deviceUuid: Uuid): Promise<void> {
    return this.notificationsDatasource.deleteDevice(deviceUuid);
  }
}

1	import { UpsertSubscriptionsDto } from '@/domain/notifications/entities-v2/upsert-subscriptions.dto.entity';
2	import { FirebaseNotification } from '@/datasources/push-notifications-api/entities/firebase-notification.entity';
3	import { INotificationsDatasource } from '@/domain/interfaces/notifications.datasource.interface';	16✔
4	import { IPushNotificationsApi } from '@/domain/interfaces/push-notifications-api.interface';	16✔
5	import { Uuid } from '@/domain/notifications/entities-v2/uuid.entity';
6	import { INotificationsRepositoryV2 } from '@/domain/notifications/notifications.repository.v2.interface';
7	import {	16✔
8	Inject,
9	Injectable,
10	UnprocessableEntityException,
11	} from '@nestjs/common';
12	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	16✔
13	import { NotificationType } from '@/domain/notifications/entities-v2/notification.entity';
14	import { get } from 'lodash';	16✔
15
16	@Injectable()
17	export class NotificationsRepositoryV2 implements INotificationsRepositoryV2 {	16✔
18	/**
19	* Firebase REST error message for the HTTP v1 API relevant to token registration:
20	*
21	* This error can be caused by missing registration tokens, or unregistered tokens.
22	*
23	* Missing Registration: If the message's target is a token value, check that the
24	* request contains a registration token.
25	*
26	* Not registered: An existing registration token may cease to be valid in a number
27	* of scenarios, including:
28	* - If the client app unregisters with FCM.
29	* - If the client app is automatically unregistered, which can happen if the user
30	* uninstalls the application. For example, on iOS, if the APNs Feedback Service
31	* reported the APNs token as invalid.
32	* - If the registration token expires (for example, Google might decide to refresh
33	* registration tokens, or the APNs token has expired for iOS devices).
34	* - If the client app is updated but the new version is not configured to receive
35	* messages.
36	*
37	* For all these cases, remove this registration token from the app server and stop
38	* using it to send messages.
39	*
40	* @see https://firebase.google.com/docs/cloud-messaging/send-message#rest
41	*/
42	static readonly UnregisteredErrorCode = 404;	16✔
43	static readonly UnregisteredErrorStatus = 'UNREGISTERED';	16✔
44
45	constructor(
46	@Inject(IPushNotificationsApi)
NEW 47	private readonly pushNotificationsApi: IPushNotificationsApi,	×
48	@Inject(INotificationsDatasource)
NEW 49	private readonly notificationsDatasource: INotificationsDatasource,	×
50	@Inject(LoggingService)
NEW 51	private readonly loggingService: ILoggingService,	×
52	) {}
53
54	async enqueueNotification(args: {
55	token: string;
56	deviceUuid: Uuid;
57	notification: FirebaseNotification;
58	}): Promise<void> {
NEW 59	try {	×
NEW 60	await this.pushNotificationsApi.enqueueNotification(	×
61	args.token,
62	args.notification,
63	);
64	} catch (e) {
NEW 65	if (this.isTokenUnregistered(e)) {	×
NEW 66	await this.deleteDevice(args.deviceUuid).catch(() => null);	×
67	} else {
NEW 68	this.loggingService.info(`Failed to enqueue notification: ${e}`);	×
NEW 69	throw new UnprocessableEntityException();	×
70	}
71	}
72	}
73
74	private isTokenUnregistered(error: unknown): boolean {
75	const isNotFound =
NEW 76	get(error, 'code') === NotificationsRepositoryV2.UnregisteredErrorCode;	×
77	const isUnregistered =
NEW 78	get(error, 'status') ===	×
79	NotificationsRepositoryV2.UnregisteredErrorStatus;
NEW 80	return isNotFound && isUnregistered;	×
81	}
82
83	async upsertSubscriptions(args: {
84	signerAddress: `0x${string}`;
85	upsertSubscriptionsDto: UpsertSubscriptionsDto;
86	}): Promise<{
87	deviceUuid: Uuid;
88	}> {
NEW 89	return this.notificationsDatasource.upsertSubscriptions(args);	×
90	}
91
92	getSafeSubscription(args: {
93	deviceUuid: Uuid;
94	chainId: string;
95	safeAddress: `0x${string}`;
96	signerAddress: `0x${string}`;
97	}): Promise<Array<NotificationType>> {
NEW 98	return this.notificationsDatasource.getSafeSubscription(args);	×
99	}
100
101	getSubscribersBySafe(args: {
102	chainId: string;
103	safeAddress: `0x${string}`;
104	}): Promise<
105	Array<{
106	subscriber: `0x${string}`;
107	deviceUuid: Uuid;
108	cloudMessagingToken: string;
109	}>
110	> {
NEW 111	return this.notificationsDatasource.getSubscribersBySafe(args);	×
112	}
113
114	deleteSubscription(args: {
115	deviceUuid: Uuid;
116	chainId: string;
117	safeAddress: `0x${string}`;
118	signerAddress: `0x${string}`;
119	}): Promise<void> {
NEW 120	return this.notificationsDatasource.deleteSubscription(args);	×
121	}
122
123	deleteDevice(deviceUuid: Uuid): Promise<void> {
NEW 124	return this.notificationsDatasource.deleteDevice(deviceUuid);	×
125	}
126	}

safe-global / safe-client-gateway / 10166116522

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