10096139348

Committed 25 Jul 2024 02:35PM UTC coverage: 47.323% (-1.2%) from 48.494%

Build # 10096139348

Build Type

Pull #1778

github

Committed by

iamacook

Commit Message

Simplify upsertion logic

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

Run Details

444 of 2744 branches covered (16.18%)

Branch coverage included in aggregate %.

43 of 186 new or added lines in 9 files covered. (23.12%)

2 existing lines in 2 files now uncovered.

4391 of 7473 relevant lines covered (58.76%)

12.71 hits per line

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

16.95

/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,
  UnauthorizedException,
  UnprocessableEntityException,
} from '@nestjs/common';
import { ISafeRepository } from '@/domain/safe/safe.repository.interface';
import { IDelegatesV2Repository } from '@/domain/delegate/v2/delegates.v2.repository.interface';
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(ISafeRepository)
    private readonly safeRepository: ISafeRepository,
    @Inject(IDelegatesV2Repository)
    private readonly delegatesRepository: IDelegatesV2Repository,
    @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: UpsertSubscriptionsDto): Promise<{
    deviceUuid: Uuid;
  }> {
    // Only allow owners or delegates to subscribe to notifications
    // We don't Promise.all getSafe/getDelegates to prevent unnecessary calls
    for (const safeToSubscribe of args.safes) {
      const safe = await this.safeRepository
        .getSafe({
          chainId: safeToSubscribe.chainId,
          address: safeToSubscribe.address,
        })
        .catch(() => null);

      const isOwner = !!safe?.owners.includes(args.account);
      if (isOwner) {
        continue;
      }

      const delegates = await this.delegatesRepository
        .getDelegates({
          chainId: safeToSubscribe.chainId,
          safeAddress: safeToSubscribe.address,
          delegate: args.account,
        })
        .catch(() => null);

      const isDelegate = !!delegates?.results.some(
        ({ delegate }) => delegate === args.account,
      );
      if (isDelegate) {
        continue;
      }

      throw new UnauthorizedException();
    }

    return this.notificationsDatasource.upsertSubscriptions(args);
  }

  getSafeSubscription(args: {
    account: `0x${string}`;
    deviceUuid: Uuid;
    chainId: string;
    safeAddress: `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: {
    account: `0x${string}`;
    deviceUuid: Uuid;
    chainId: string;
    safeAddress: `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	UnauthorizedException,
11	UnprocessableEntityException,
12	} from '@nestjs/common';
13	import { ISafeRepository } from '@/domain/safe/safe.repository.interface';	16✔
14	import { IDelegatesV2Repository } from '@/domain/delegate/v2/delegates.v2.repository.interface';	16✔
15	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	16✔
16	import { NotificationType } from '@/domain/notifications/entities-v2/notification.entity';
17	import { get } from 'lodash';	16✔
18
19	@Injectable()
20	export class NotificationsRepositoryV2 implements INotificationsRepositoryV2 {	16✔
21	/**
22	* Firebase REST error message for the HTTP v1 API relevant to token registration:
23	*
24	* This error can be caused by missing registration tokens, or unregistered tokens.
25	*
26	* Missing Registration: If the message's target is a token value, check that the
27	* request contains a registration token.
28	*
29	* Not registered: An existing registration token may cease to be valid in a number
30	* of scenarios, including:
31	* - If the client app unregisters with FCM.
32	* - If the client app is automatically unregistered, which can happen if the user
33	* uninstalls the application. For example, on iOS, if the APNs Feedback Service
34	* reported the APNs token as invalid.
35	* - If the registration token expires (for example, Google might decide to refresh
36	* registration tokens, or the APNs token has expired for iOS devices).
37	* - If the client app is updated but the new version is not configured to receive
38	* messages.
39	*
40	* For all these cases, remove this registration token from the app server and stop
41	* using it to send messages.
42	*
43	* @see https://firebase.google.com/docs/cloud-messaging/send-message#rest
44	*/
45	static readonly UnregisteredErrorCode = 404;	16✔
46	static readonly UnregisteredErrorStatus = 'UNREGISTERED';	16✔
47
48	constructor(
49	@Inject(IPushNotificationsApi)
NEW 50	private readonly pushNotificationsApi: IPushNotificationsApi,	×
51	@Inject(INotificationsDatasource)
NEW 52	private readonly notificationsDatasource: INotificationsDatasource,	×
53	@Inject(ISafeRepository)
NEW 54	private readonly safeRepository: ISafeRepository,	×
55	@Inject(IDelegatesV2Repository)
NEW 56	private readonly delegatesRepository: IDelegatesV2Repository,	×
57	@Inject(LoggingService)
NEW 58	private readonly loggingService: ILoggingService,	×
59	) {}
60
61	async enqueueNotification(args: {
62	token: string;
63	deviceUuid: Uuid;
64	notification: FirebaseNotification;
65	}): Promise<void> {
NEW 66	try {	×
NEW 67	await this.pushNotificationsApi.enqueueNotification(	×
68	args.token,
69	args.notification,
70	);
71	} catch (e) {
NEW 72	if (this.isTokenUnregistered(e)) {	×
NEW 73	await this.deleteDevice(args.deviceUuid).catch(() => null);	×
74	} else {
NEW 75	this.loggingService.info(`Failed to enqueue notification: ${e}`);	×
NEW 76	throw new UnprocessableEntityException();	×
77	}
78	}
79	}
80
81	private isTokenUnregistered(error: unknown): boolean {
82	const isNotFound =
NEW 83	get(error, 'code') === NotificationsRepositoryV2.UnregisteredErrorCode;	×
84	const isUnregistered =
NEW 85	get(error, 'status') ===	×
86	NotificationsRepositoryV2.UnregisteredErrorStatus;
NEW 87	return isNotFound && isUnregistered;	×
88	}
89
90	async upsertSubscriptions(args: UpsertSubscriptionsDto): Promise<{
91	deviceUuid: Uuid;
92	}> {
93	// Only allow owners or delegates to subscribe to notifications
94	// We don't Promise.all getSafe/getDelegates to prevent unnecessary calls
NEW 95	for (const safeToSubscribe of args.safes) {	×
NEW 96	const safe = await this.safeRepository	×
97	.getSafe({
98	chainId: safeToSubscribe.chainId,
99	address: safeToSubscribe.address,
100	})
NEW 101	.catch(() => null);	×
102
NEW 103	const isOwner = !!safe?.owners.includes(args.account);	×
NEW 104	if (isOwner) {	×
NEW 105	continue;	×
106	}
107
NEW 108	const delegates = await this.delegatesRepository	×
109	.getDelegates({
110	chainId: safeToSubscribe.chainId,
111	safeAddress: safeToSubscribe.address,
112	delegate: args.account,
113	})
NEW 114	.catch(() => null);	×
115
NEW 116	const isDelegate = !!delegates?.results.some(	×
NEW 117	({ delegate }) => delegate === args.account,	×
118	);
NEW 119	if (isDelegate) {	×
NEW 120	continue;	×
121	}
122
NEW 123	throw new UnauthorizedException();	×
124	}
125
NEW 126	return this.notificationsDatasource.upsertSubscriptions(args);	×
127	}
128
129	getSafeSubscription(args: {
130	account: `0x${string}`;
131	deviceUuid: Uuid;
132	chainId: string;
133	safeAddress: `0x${string}`;
134	}): Promise<Array<NotificationType>> {
NEW 135	return this.notificationsDatasource.getSafeSubscription(args);	×
136	}
137
138	getSubscribersBySafe(args: {
139	chainId: string;
140	safeAddress: `0x${string}`;
141	}): Promise<
142	Array<{
143	subscriber: `0x${string}`;
144	deviceUuid: Uuid;
145	cloudMessagingToken: string;
146	}>
147	> {
NEW 148	return this.notificationsDatasource.getSubscribersBySafe(args);	×
149	}
150
151	deleteSubscription(args: {
152	account: `0x${string}`;
153	deviceUuid: Uuid;
154	chainId: string;
155	safeAddress: `0x${string}`;
156	}): Promise<void> {
NEW 157	return this.notificationsDatasource.deleteSubscription(args);	×
158	}
159
160	deleteDevice(deviceUuid: Uuid): Promise<void> {
NEW 161	return this.notificationsDatasource.deleteDevice(deviceUuid);	×
162	}
163	}

safe-global / safe-client-gateway / 10096139348

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