10452769483

Committed 19 Aug 2024 11:49AM UTC coverage: 46.903% (-0.04%) from 46.946%

Build # 10452769483

Build Type

Pull #1797

github

Committed by

iamacook

Commit Message

Address comments

Pull Request Pull Request #1797: Allow optional signature when registering notifications

Run Details

464 of 2874 branches covered (16.14%)

Branch coverage included in aggregate %.

6 of 19 new or added lines in 5 files covered. (31.58%)

5 existing lines in 2 files now uncovered.

4549 of 7814 relevant lines covered (58.22%)

12.57 hits per line

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

8.33

/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 (optional)
   * @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.warn(`${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. Delete previous subscriptions (and by cascade, notification types)
            //    to avoid duplicates, and clearing "unknown" subscriptions
            await sql`
              DELETE FROM notification_subscriptions
              WHERE chain_id = ${safe.chainId}
              AND safe_address = ${safe.address}
              AND (
                signer_address = ${args.signerAddress ?? null}
                OR (
                  signer_address IS NULL
                )
              )
              AND push_notification_device_id = ${device.id}
            `;

            // 2. 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 ?? null}, ${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
            `;

            // 3. Insert 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.warn(`${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.warn(`${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}` | null;
      deviceUuid: UUID;
      cloudMessagingToken: string;
    }>
  > {
    const subscribers = await this.sql<
      Array<{
        signer_address: `0x${string}` | null;
        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.warn(`${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.warn(`${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.warn(`${error}: ${asError(e).message}`);
      throw new UnprocessableEntityException(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 (optional)
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.warn(`${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. Delete previous subscriptions (and by cascade, notification types)
63	// to avoid duplicates, and clearing "unknown" subscriptions
NEW 64	await sql`	×
65	DELETE FROM notification_subscriptions
66	WHERE chain_id = ${safe.chainId}
67	AND safe_address = ${safe.address}
68	AND (
69	signer_address = ${args.signerAddress ?? null}	×
70	OR (
71	signer_address IS NULL
72	)
73	)
74	AND push_notification_device_id = ${device.id}
75	`;
76
77	// 2. Upsert subscription
UNCOV 78	const [subscription] = await sql<[{ id: number }]>`	×
79	INSERT INTO notification_subscriptions (chain_id, safe_address, signer_address, push_notification_device_id)
80	VALUES (${safe.chainId}, ${safe.address}, ${args.signerAddress ?? null}, ${device.id})	×
81	ON CONFLICT (chain_id, safe_address, signer_address, push_notification_device_id)
82	-- If no value is set ON CONFLICT, an error is thrown meaning nothing is returned
83	DO UPDATE SET updated_at = NOW()
84	RETURNING id
85	`;
86
87	// 3. Insert subscribed-to notification types
UNCOV 88	await sql`	×
89	INSERT INTO notification_subscription_notification_types (notification_subscription_id, notification_type_id)
90	SELECT ${subscription.id}, id
91	FROM notification_types
92	WHERE name = ANY(${safe.notificationTypes})
93	`;
94	} catch (e) {
95	const error = 'Error upserting subscription';	×
96	this.loggingService.warn(`${error}: ${asError(e).message}`);	×
97	throw new NotFoundException();	×
98	}
99	}),
100	);
101	});
102
103	return { deviceUuid };	×
104	}
105
106	/**
107	* Gets notification preferences for given signer/device for the given Safe.
108	*
109	* @param args.deviceUuid Device UUID
110	* @param args.chainId Chain ID
111	* @param args.safeAddress Safe address
112	* @param args.signerAddress Signer address
113	*
114	* @returns List of {@link DomainNotificationType} notifications subscribed to
115	*/
116	async getSafeSubscription(args: {
117	deviceUuid: UUID;
118	chainId: string;
119	safeAddress: `0x${string}`;
120	signerAddress: `0x${string}`;
121	}): Promise<Array<DomainNotificationType>> {
122	const notificationTypes = await this.sql<	×
123	Array<{ name: DomainNotificationType }>
124	>`
125	SELECT nt.name
126	FROM notification_subscriptions ns
127	JOIN push_notification_devices pnd ON ns.push_notification_device_id = pnd.id
128	JOIN notification_subscription_notification_types nsnt ON ns.id = nsnt.notification_subscription_id
129	JOIN notification_types nt ON nsnt.notification_type_id = nt.id
130	WHERE ns.chain_id = ${args.chainId}
131	AND ns.safe_address = ${args.safeAddress}
132	AND ns.signer_address = ${args.signerAddress}
133	AND pnd.device_uuid = ${args.deviceUuid}
134	`.catch((e) => {
135	const error = 'Error getting subscription or notification types';	×
136	this.loggingService.warn(`${error}: ${asError(e).message}`);	×
137	throw new NotFoundException(error);	×
138	});
139
140	return notificationTypes.map((notificationType) => notificationType.name);	×
141	}
142
143	/**
144	* Gets subscribers and their device UUID/cloud messaging tokens for the given Safe.
145	*
146	* @param args.chainId Chain ID
147	* @param args.safeAddress Safe address
148	*
149	* @returns List of subscribers/tokens for given Safe
150	*/
151	async getSubscribersBySafe(args: {
152	chainId: string;
153	safeAddress: string;
154	}): Promise<
155	Array<{
156	subscriber: `0x${string}` \| null;
157	deviceUuid: UUID;
158	cloudMessagingToken: string;
159	}>
160	> {
161	const subscribers = await this.sql<	×
162	Array<{
163	signer_address: `0x${string}` \| null;
164	cloud_messaging_token: string;
165	device_uuid: UUID;
166	}>
167	>`
168	SELECT
169	pd.cloud_messaging_token,
170	ns.signer_address,
171	pd.device_uuid
172	FROM
173	push_notification_devices pd
174	JOIN
175	notification_subscriptions ns ON pd.id = ns.push_notification_device_id
176	WHERE
177	ns.chain_id = ${args.chainId}
178	AND ns.safe_address = ${args.safeAddress};
179	`.catch((e) => {
180	const error = 'Error getting subscribers with tokens';	×
181	this.loggingService.warn(`${error}: ${asError(e).message}`);	×
182	throw new NotFoundException(error);	×
183	});
184
185	return subscribers.map((subscriber) => {	×
186	return {	×
187	subscriber: subscriber.signer_address,
188	deviceUuid: subscriber.device_uuid,
189	cloudMessagingToken: subscriber.cloud_messaging_token,
190	};
191	});
192	}
193
194	/**
195	* Deletes the Safe subscription for the given signer/device.
196	*
197	* @param args.deviceUuid Device UUID
198	* @param args.chainId Chain ID
199	* @param args.safeAddress Safe address
200	* @param args.signerAddress Signer address
201	*/
202	async deleteSubscription(args: {
203	deviceUuid: UUID;
204	chainId: string;
205	safeAddress: `0x${string}`;
206	}): Promise<void> {
207	await this.sql.begin(async (sql) => {	×
208	try {	×
209	// 1. Delete the subscription and return device ID
210	const [deletedSubscription] = await sql<	×
211	[{ push_notification_device_id: number }]
212	>`
213	DELETE FROM notification_subscriptions ns
214	USING push_notification_devices pnd
215	WHERE ns.push_notification_device_id = pnd.id
216	AND pnd.device_uuid = ${args.deviceUuid}
217	AND ns.chain_id = ${args.chainId}
218	AND ns.safe_address = ${args.safeAddress}
219	RETURNING ns.push_notification_device_id;
220	`;
221
222	// 2. Check if there any remaining subscriptions for device
223	const remainingSubscriptions = await sql`	×
224	SELECT 1
225	FROM notification_subscriptions
226	WHERE push_notification_device_id = ${deletedSubscription.push_notification_device_id}
227	`;
228
229	// 3. If no subscriptions, delete orphaned device
230	if (remainingSubscriptions.length === 0) {	×
231	// Note: we can't use this.deleteDevice here as we are in a transaction
232	await sql`	×
233	DELETE FROM push_notification_devices
234	WHERE device_uuid = ${args.deviceUuid}
235	`;
236	}
237	} catch (e) {
238	const error = 'Error deleting subscription';	×
239	this.loggingService.warn(`${error}: ${asError(e).message}`);	×
240	throw new NotFoundException(error);	×
241	}
242	});
243	}
244
245	/**
246	* Deletes subscriptions for the given device UUID.
247	*
248	* @param deviceUuid Device UUID
249	*/
250	async deleteDevice(deviceUuid: UUID): Promise<void> {
251	await this.sql`	×
252	DELETE FROM push_notification_devices
253	WHERE device_uuid = ${deviceUuid}
254	`.catch((e) => {
255	const error = 'Error deleting device';	×
256	this.loggingService.warn(`${error}: ${asError(e).message}`);	×
257	throw new UnprocessableEntityException(error);	×
258	});
259	}
260	}

safe-global / safe-client-gateway / 10452769483

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