10182461815

Committed 31 Jul 2024 02:46PM UTC coverage: 47.286% (+0.2%) from 47.078%

Build # 10182461815

Build Type

Pull #1787

github

Committed by

iamacook

Commit Message

Remove comment

Pull Request Pull Request #1787: Add v2 notifications routes

Run Details

456 of 2805 branches covered (16.26%)

Branch coverage included in aggregate %.

34 of 57 new or added lines in 8 files covered. (59.65%)

1 existing line in 1 file now uncovered.

4457 of 7585 relevant lines covered (58.76%)

12.68 hits per line

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

9.8

/src/datasources/notifications/notifications.datasource.ts

import { NotificationType as DomainNotificationType } from '@/domain/notifications/entities-v2/notification-type.entity';
import { UUID } from 'crypto';
import { INotificationsDatasource } from '@/domain/interfaces/notifications.datasource.interface';
import { LoggingService, ILoggingService } from '@/logging/logging.interface';
import { asError } from '@/logging/utils';
import {
  Inject,
  Injectable,
  NotFoundException,
  UnprocessableEntityException,
} from '@nestjs/common';
import postgres from 'postgres';
import { UpsertSubscriptionsDto } from '@/routes/notifications/entities/upsert-subscriptions.dto.entity';

@Injectable()
export class NotificationsDatasource implements INotificationsDatasource {
  constructor(
    @Inject('DB_INSTANCE')
    private readonly sql: postgres.Sql,
    @Inject(LoggingService)
    private readonly loggingService: ILoggingService,
  ) {}

  /**
   * Upserts subscriptions for the given signer/device as per the list of Safes
   * and notification types provided.
   *
   * @param args.signerAddress Signer address
   * @param args.upsertSubscriptionsDto {@link UpsertSubscriptionsDto} DTO
   *
   * @returns Device UUID
   */
  async upsertSubscriptions(args: {
    signerAddress: `0x${string}`;
    upsertSubscriptionsDto: UpsertSubscriptionsDto;
  }): Promise<{ deviceUuid: UUID }> {
    const deviceUuid =
      args.upsertSubscriptionsDto.deviceUuid ?? crypto.randomUUID();

    await this.sql.begin(async (sql) => {
      // Insert (or update the type/cloud messaging token of) a device
      const [device] = await sql<[{ id: number }]>`
        INSERT INTO push_notification_devices (device_type, device_uuid, cloud_messaging_token)
        VALUES (${args.upsertSubscriptionsDto.deviceType}, ${deviceUuid}, ${args.upsertSubscriptionsDto.cloudMessagingToken})
        ON CONFLICT (device_uuid)
        DO UPDATE SET
          cloud_messaging_token = EXCLUDED.cloud_messaging_token,
          device_type = EXCLUDED.device_type,
          -- If updated_at is not set ON CONFLICT, an error is thrown meaning nothing is returned
          updated_at = NOW()
        RETURNING id
      `.catch((e) => {
        const error = 'Error getting device';
        this.loggingService.info(`${error}: ${asError(e).message}`);
        throw new UnprocessableEntityException(error);
      });

      // For each Safe, upsert the subscription and overwrite the subscribed-to notification types
      await Promise.all(
        args.upsertSubscriptionsDto.safes.map(async (safe) => {
          try {
            // 1. Upsert subscription
            const [subscription] = await sql<[{ id: number }]>`
              INSERT INTO notification_subscriptions (chain_id, safe_address, signer_address, push_notification_device_id)
              VALUES (${safe.chainId}, ${safe.address}, ${args.signerAddress}, ${device.id})
              ON CONFLICT (chain_id, safe_address, signer_address, push_notification_device_id)
                -- If no value is set ON CONFLICT, an error is thrown meaning nothing is returned
                DO UPDATE SET updated_at = NOW()
              RETURNING id
            `;
            // 2. Remove existing subscribed-to notification types
            await sql`
              DELETE FROM notification_subscription_notification_types
              WHERE notification_subscription_id = ${subscription.id}
            `;
            // 3. Insert new subscribed-to notification types
            await sql`
              INSERT INTO notification_subscription_notification_types (notification_subscription_id, notification_type_id)
              SELECT ${subscription.id}, id
              FROM notification_types
              WHERE name = ANY(${safe.notificationTypes})
            `;
          } catch (e) {
            const error = 'Error upserting subscription';
            this.loggingService.info(`${error}: ${asError(e).message}`);
            throw new NotFoundException();
          }
        }),
      );
    });

    return { deviceUuid };
  }

  /**
   * Gets notification preferences for given signer/device for the given Safe.
   *
   * @param args.deviceUuid Device UUID
   * @param args.chainId Chain ID
   * @param args.safeAddress Safe address
   * @param args.signerAddress Signer address
   *
   * @returns List of {@link DomainNotificationType} notifications subscribed to
   */
  async getSafeSubscription(args: {
    deviceUuid: UUID;
    chainId: string;
    safeAddress: `0x${string}`;
    signerAddress: `0x${string}`;
  }): Promise<Array<DomainNotificationType>> {
    const notificationTypes = await this.sql<
      Array<{ name: DomainNotificationType }>
    >`
      SELECT nt.name 
      FROM notification_subscriptions ns
      JOIN push_notification_devices pnd ON ns.push_notification_device_id = pnd.id
      JOIN notification_subscription_notification_types nsnt ON ns.id = nsnt.notification_subscription_id
      JOIN notification_types nt ON nsnt.notification_type_id = nt.id
      WHERE ns.chain_id = ${args.chainId}
        AND ns.safe_address = ${args.safeAddress}
        AND ns.signer_address = ${args.signerAddress}
        AND pnd.device_uuid = ${args.deviceUuid}
    `.catch((e) => {
      const error = 'Error getting subscription or notification types';
      this.loggingService.info(`${error}: ${asError(e).message}`);
      throw new NotFoundException(error);
    });

    return notificationTypes.map((notificationType) => notificationType.name);
  }

  /**
   * Gets subscribers and their device UUID/cloud messaging tokens for the given Safe.
   *
   * @param args.chainId Chain ID
   * @param args.safeAddress Safe address
   *
   * @returns List of subscribers/tokens for given Safe
   */
  async getSubscribersBySafe(args: {
    chainId: string;
    safeAddress: string;
  }): Promise<
    Array<{
      subscriber: `0x${string}`;
      deviceUuid: UUID;
      cloudMessagingToken: string;
    }>
  > {
    const subscribers = await this.sql<
      Array<{
        signer_address: `0x${string}`;
        cloud_messaging_token: string;
        device_uuid: UUID;
      }>
    >`
      SELECT 
        pd.cloud_messaging_token,
        ns.signer_address,
        pd.device_uuid
      FROM 
        push_notification_devices pd
      JOIN 
        notification_subscriptions ns ON pd.id = ns.push_notification_device_id
      WHERE 
        ns.chain_id = ${args.chainId}
        AND ns.safe_address = ${args.safeAddress};
    `.catch((e) => {
      const error = 'Error getting subscribers with tokens';
      this.loggingService.info(`${error}: ${asError(e).message}`);
      throw new NotFoundException(error);
    });

    return subscribers.map((subscriber) => {
      return {
        subscriber: subscriber.signer_address,
        deviceUuid: subscriber.device_uuid,
        cloudMessagingToken: subscriber.cloud_messaging_token,
      };
    });
  }

  /**
   * Deletes the Safe subscription for the given signer/device.
   *
   * @param args.deviceUuid Device UUID
   * @param args.chainId Chain ID
   * @param args.safeAddress Safe address
   * @param args.signerAddress Signer address
   */
  async deleteSubscription(args: {
    deviceUuid: UUID;
    chainId: string;
    safeAddress: `0x${string}`;
  }): Promise<void> {
    await this.sql.begin(async (sql) => {
      try {
        // 1. Delete the subscription and return device ID
        const [deletedSubscription] = await sql<
          [{ push_notification_device_id: number }]
        >`
          DELETE FROM notification_subscriptions ns
          USING push_notification_devices pnd
          WHERE ns.push_notification_device_id = pnd.id
            AND pnd.device_uuid = ${args.deviceUuid}
            AND ns.chain_id = ${args.chainId}
            AND ns.safe_address = ${args.safeAddress}
          RETURNING ns.push_notification_device_id;
        `;

        // 2. Check if there any remaining subscriptions for device
        const remainingSubscriptions = await sql`
          SELECT 1
          FROM notification_subscriptions
          WHERE push_notification_device_id = ${deletedSubscription.push_notification_device_id}
        `;

        // 3. If no subscriptions, delete orphaned device
        if (remainingSubscriptions.length === 0) {
          // Note: we can't use this.deleteDevice here as we are in a transaction
          await sql`
            DELETE FROM push_notification_devices
            WHERE device_uuid = ${args.deviceUuid}
          `;
        }
      } catch (e) {
        const error = 'Error deleting subscription';
        this.loggingService.info(`${error}: ${asError(e).message}`);
        throw new NotFoundException(error);
      }
    });
  }

  /**
   * Deletes subscriptions for the given device UUID.
   *
   * @param deviceUuid Device UUID
   */
  async deleteDevice(deviceUuid: UUID): Promise<void> {
    await this.sql`
      DELETE FROM push_notification_devices
      WHERE device_uuid = ${deviceUuid}
    `.catch((e) => {
      const error = 'Error deleting device';
      this.loggingService.info(`${error}: ${asError(e).message}`);
      throw new NotFoundException(error);
    });
  }
}

1	import { NotificationType as DomainNotificationType } from '@/domain/notifications/entities-v2/notification-type.entity';
2	import { UUID } from 'crypto';
3	import { INotificationsDatasource } from '@/domain/interfaces/notifications.datasource.interface';
4	import { LoggingService, ILoggingService } from '@/logging/logging.interface';	16✔
5	import { asError } from '@/logging/utils';	16✔
6	import {	16✔
7	Inject,
8	Injectable,
9	NotFoundException,
10	UnprocessableEntityException,
11	} from '@nestjs/common';
12	import postgres from 'postgres';	16✔
13	import { UpsertSubscriptionsDto } from '@/routes/notifications/entities/upsert-subscriptions.dto.entity';
14
15	@Injectable()
16	export class NotificationsDatasource implements INotificationsDatasource {	16✔
17	constructor(
18	@Inject('DB_INSTANCE')
19	private readonly sql: postgres.Sql,	×
20	@Inject(LoggingService)
21	private readonly loggingService: ILoggingService,	×
22	) {}
23
24	/**
25	* Upserts subscriptions for the given signer/device as per the list of Safes
26	* and notification types provided.
27	*
28	* @param args.signerAddress Signer address
29	* @param args.upsertSubscriptionsDto {@link UpsertSubscriptionsDto} DTO
30	*
31	* @returns Device UUID
32	*/
33	async upsertSubscriptions(args: {
34	signerAddress: `0x${string}`;
35	upsertSubscriptionsDto: UpsertSubscriptionsDto;
36	}): Promise<{ deviceUuid: UUID }> {
37	const deviceUuid =
38	args.upsertSubscriptionsDto.deviceUuid ?? crypto.randomUUID();	×
39
40	await this.sql.begin(async (sql) => {	×
41	// Insert (or update the type/cloud messaging token of) a device
42	const [device] = await sql<[{ id: number }]>`	×
43	INSERT INTO push_notification_devices (device_type, device_uuid, cloud_messaging_token)
44	VALUES (${args.upsertSubscriptionsDto.deviceType}, ${deviceUuid}, ${args.upsertSubscriptionsDto.cloudMessagingToken})
45	ON CONFLICT (device_uuid)
46	DO UPDATE SET
47	cloud_messaging_token = EXCLUDED.cloud_messaging_token,
48	device_type = EXCLUDED.device_type,
49	-- If updated_at is not set ON CONFLICT, an error is thrown meaning nothing is returned
50	updated_at = NOW()
51	RETURNING id
52	`.catch((e) => {
53	const error = 'Error getting device';	×
54	this.loggingService.info(`${error}: ${asError(e).message}`);	×
55	throw new UnprocessableEntityException(error);	×
56	});
57
58	// For each Safe, upsert the subscription and overwrite the subscribed-to notification types
59	await Promise.all(	×
60	args.upsertSubscriptionsDto.safes.map(async (safe) => {
61	try {	×
62	// 1. Upsert subscription
63	const [subscription] = await sql<[{ id: number }]>`	×
64	INSERT INTO notification_subscriptions (chain_id, safe_address, signer_address, push_notification_device_id)
65	VALUES (${safe.chainId}, ${safe.address}, ${args.signerAddress}, ${device.id})
66	ON CONFLICT (chain_id, safe_address, signer_address, push_notification_device_id)
67	-- If no value is set ON CONFLICT, an error is thrown meaning nothing is returned
68	DO UPDATE SET updated_at = NOW()
69	RETURNING id
70	`;
71	// 2. Remove existing subscribed-to notification types
72	await sql`	×
73	DELETE FROM notification_subscription_notification_types
74	WHERE notification_subscription_id = ${subscription.id}
75	`;
76	// 3. Insert new subscribed-to notification types
77	await sql`	×
78	INSERT INTO notification_subscription_notification_types (notification_subscription_id, notification_type_id)
79	SELECT ${subscription.id}, id
80	FROM notification_types
81	WHERE name = ANY(${safe.notificationTypes})
82	`;
83	} catch (e) {
84	const error = 'Error upserting subscription';	×
85	this.loggingService.info(`${error}: ${asError(e).message}`);	×
86	throw new NotFoundException();	×
87	}
88	}),
89	);
90	});
91
92	return { deviceUuid };	×
93	}
94
95	/**
96	* Gets notification preferences for given signer/device for the given Safe.
97	*
98	* @param args.deviceUuid Device UUID
99	* @param args.chainId Chain ID
100	* @param args.safeAddress Safe address
101	* @param args.signerAddress Signer address
102	*
103	* @returns List of {@link DomainNotificationType} notifications subscribed to
104	*/
105	async getSafeSubscription(args: {
106	deviceUuid: UUID;
107	chainId: string;
108	safeAddress: `0x${string}`;
109	signerAddress: `0x${string}`;
110	}): Promise<Array<DomainNotificationType>> {
111	const notificationTypes = await this.sql<	×
112	Array<{ name: DomainNotificationType }>
113	>`
114	SELECT nt.name
115	FROM notification_subscriptions ns
116	JOIN push_notification_devices pnd ON ns.push_notification_device_id = pnd.id
117	JOIN notification_subscription_notification_types nsnt ON ns.id = nsnt.notification_subscription_id
118	JOIN notification_types nt ON nsnt.notification_type_id = nt.id
119	WHERE ns.chain_id = ${args.chainId}
120	AND ns.safe_address = ${args.safeAddress}
121	AND ns.signer_address = ${args.signerAddress}
122	AND pnd.device_uuid = ${args.deviceUuid}
123	`.catch((e) => {
124	const error = 'Error getting subscription or notification types';	×
125	this.loggingService.info(`${error}: ${asError(e).message}`);	×
126	throw new NotFoundException(error);	×
127	});
128
129	return notificationTypes.map((notificationType) => notificationType.name);	×
130	}
131
132	/**
133	* Gets subscribers and their device UUID/cloud messaging tokens for the given Safe.
134	*
135	* @param args.chainId Chain ID
136	* @param args.safeAddress Safe address
137	*
138	* @returns List of subscribers/tokens for given Safe
139	*/
140	async getSubscribersBySafe(args: {
141	chainId: string;
142	safeAddress: string;
143	}): Promise<
144	Array<{
145	subscriber: `0x${string}`;
146	deviceUuid: UUID;
147	cloudMessagingToken: string;
148	}>
149	> {
150	const subscribers = await this.sql<	×
151	Array<{
152	signer_address: `0x${string}`;
153	cloud_messaging_token: string;
154	device_uuid: UUID;
155	}>
156	>`
157	SELECT
158	pd.cloud_messaging_token,
159	ns.signer_address,
160	pd.device_uuid
161	FROM
162	push_notification_devices pd
163	JOIN
164	notification_subscriptions ns ON pd.id = ns.push_notification_device_id
165	WHERE
166	ns.chain_id = ${args.chainId}
167	AND ns.safe_address = ${args.safeAddress};
168	`.catch((e) => {
169	const error = 'Error getting subscribers with tokens';	×
170	this.loggingService.info(`${error}: ${asError(e).message}`);	×
171	throw new NotFoundException(error);	×
172	});
173
174	return subscribers.map((subscriber) => {	×
175	return {	×
176	subscriber: subscriber.signer_address,
177	deviceUuid: subscriber.device_uuid,
178	cloudMessagingToken: subscriber.cloud_messaging_token,
179	};
180	});
181	}
182
183	/**
184	* Deletes the Safe subscription for the given signer/device.
185	*
186	* @param args.deviceUuid Device UUID
187	* @param args.chainId Chain ID
188	* @param args.safeAddress Safe address
189	* @param args.signerAddress Signer address
190	*/
191	async deleteSubscription(args: {
192	deviceUuid: UUID;
193	chainId: string;
194	safeAddress: `0x${string}`;
195	}): Promise<void> {
UNCOV 196	await this.sql.begin(async (sql) => {	×
197	try {	×
198	// 1. Delete the subscription and return device ID
199	const [deletedSubscription] = await sql<	×
200	[{ push_notification_device_id: number }]
201	>`
202	DELETE FROM notification_subscriptions ns
203	USING push_notification_devices pnd
204	WHERE ns.push_notification_device_id = pnd.id
205	AND pnd.device_uuid = ${args.deviceUuid}
206	AND ns.chain_id = ${args.chainId}
207	AND ns.safe_address = ${args.safeAddress}
208	RETURNING ns.push_notification_device_id;
209	`;
210
211	// 2. Check if there any remaining subscriptions for device
212	const remainingSubscriptions = await sql`	×
213	SELECT 1
214	FROM notification_subscriptions
215	WHERE push_notification_device_id = ${deletedSubscription.push_notification_device_id}
216	`;
217
218	// 3. If no subscriptions, delete orphaned device
219	if (remainingSubscriptions.length === 0) {	×
220	// Note: we can't use this.deleteDevice here as we are in a transaction
221	await sql`	×
222	DELETE FROM push_notification_devices
223	WHERE device_uuid = ${args.deviceUuid}
224	`;
225	}
226	} catch (e) {
227	const error = 'Error deleting subscription';	×
228	this.loggingService.info(`${error}: ${asError(e).message}`);	×
229	throw new NotFoundException(error);	×
230	}
231	});
232	}
233
234	/**
235	* Deletes subscriptions for the given device UUID.
236	*
237	* @param deviceUuid Device UUID
238	*/
239	async deleteDevice(deviceUuid: UUID): Promise<void> {
240	await this.sql`	×
241	DELETE FROM push_notification_devices
242	WHERE device_uuid = ${deviceUuid}
243	`.catch((e) => {
244	const error = 'Error deleting device';	×
245	this.loggingService.info(`${error}: ${asError(e).message}`);	×
NEW 246	throw new NotFoundException(error);	×
247	});
248	}
249	}

safe-global / safe-client-gateway / 10182461815

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