8580860003

Committed 06 Apr 2024 11:37AM UTC coverage: 94.548% (-0.6%) from 95.105%

Build # 8580860003

Build Type

Pull #965

github

Committed by

web-flow

Commit Message

Merge 79a173739 into e57800051

Pull Request Pull Request #965: feat: detailed error handling

Run Details

371 of 394 branches covered (94.16%)

Branch coverage included in aggregate %.

46 of 52 new or added lines in 7 files covered. (88.46%)

10 existing lines in 3 files now uncovered.

895 of 945 relevant lines covered (94.71%)

17.21 hits per line

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

94.9

/src/hooks/useNotifications.ts

import axios, { AxiosError } from 'axios';
import { useCallback, useState } from 'react';

import {
  AccountNotifications,
  AuthState,
  SettingsState,
  FailureType,
} from '../types';
import { GithubRESTError, Notification } from '../typesGithub';
import { apiRequestAuth } from '../utils/api-requests';
import {
  getEnterpriseAccountToken,
  generateGitHubAPIUrl,
  isEnterpriseHost,
  getTokenForHost,
} from '../utils/helpers';
import { removeNotification } from '../utils/remove-notification';
import {
  triggerNativeNotifications,
  setTrayIconColor,
} from '../utils/notifications';
import Constants from '../utils/constants';
import { removeNotifications } from '../utils/remove-notifications';
import { getGitifySubjectDetails } from '../utils/subject';

interface NotificationsState {
  notifications: AccountNotifications[];
  removeNotificationFromState: (id: string, hostname: string) => void;
  fetchNotifications: (
    accounts: AuthState,
    settings: SettingsState,
  ) => Promise<void>;
  markNotificationRead: (
    accounts: AuthState,
    id: string,
    hostname: string,
  ) => Promise<void>;
  markNotificationDone: (
    accounts: AuthState,
    id: string,
    hostname: string,
  ) => Promise<void>;
  unsubscribeNotification: (
    accounts: AuthState,
    id: string,
    hostname: string,
  ) => Promise<void>;
  markRepoNotifications: (
    accounts: AuthState,
    repoSlug: string,
    hostname: string,
  ) => Promise<void>;
  markRepoNotificationsDone: (
    accounts: AuthState,
    repoSlug: string,
    hostname: string,
  ) => Promise<void>;
  isFetching: boolean;
  requestFailed: boolean;
  failureType: FailureType;
}

export const useNotifications = (colors: boolean): NotificationsState => {
  const [isFetching, setIsFetching] = useState(false);
  const [requestFailed, setRequestFailed] = useState(false);
  const [failureType, setFailureType] = useState<FailureType>();

  const [notifications, setNotifications] = useState<AccountNotifications[]>(
    [],
  );

  const fetchNotifications = useCallback(
    async (accounts: AuthState, settings: SettingsState) => {
      const isGitHubLoggedIn = accounts.token !== null;
      const endpointSuffix = `notifications?participating=${settings.participating}`;

      function getGitHubNotifications() {
        if (!isGitHubLoggedIn) {
          return;
        }
        const url = `${generateGitHubAPIUrl(
          Constants.DEFAULT_AUTH_OPTIONS.hostname,
        )}${endpointSuffix}`;
        return apiRequestAuth(url, 'GET', accounts.token);
      }

      function getEnterpriseNotifications() {
        return accounts.enterpriseAccounts.map((account) => {
          const url = `${generateGitHubAPIUrl(
            account.hostname,
          )}${endpointSuffix}`;
          return apiRequestAuth(url, 'GET', account.token);
        });
      }

      setIsFetching(true);
      setFailureType(null);
      setRequestFailed(false);

      return axios
        .all([getGitHubNotifications(), ...getEnterpriseNotifications()])
        .then(
          axios.spread((gitHubNotifications, ...entAccNotifications) => {
            const enterpriseNotifications = entAccNotifications.map(
              (accountNotifications) => {
                const { hostname } = new URL(accountNotifications.config.url);
                return {
                  hostname,
                  notifications: accountNotifications.data.map(
                    (notification: Notification) => {
                      return {
                        ...notification,
                        hostname: hostname,
                      };
                    },
                  ),
                };
              },
            );
            const data = isGitHubLoggedIn
              ? [
                  ...enterpriseNotifications,
                  {
                    hostname: Constants.DEFAULT_AUTH_OPTIONS.hostname,
                    notifications: gitHubNotifications.data.map(
                      (notification: Notification) => {
                        return {
                          ...notification,
                          hostname: Constants.DEFAULT_AUTH_OPTIONS.hostname,
                        };
                      },
                    ),
                  },
                ]
              : [...enterpriseNotifications];

            if (colors === false) {
              setNotifications(data);
              triggerNativeNotifications(
                notifications,
                data,
                settings,
                accounts,
              );
              setIsFetching(false);
              return;
            }
            axios
              .all(
                data.map(async (accountNotifications) => {
                  return {
                    hostname: accountNotifications.hostname,
                    notifications: await axios
                      .all<Notification>(
                        accountNotifications.notifications.map(
                          async (notification: Notification) => {
                            const token = getTokenForHost(
                              notification.hostname,
                              accounts,
                            );

                            const additionalSubjectDetails =
                              await getGitifySubjectDetails(
                                notification,
                                token,
                              );

                            return {
                              ...notification,
                              subject: {
                                ...notification.subject,
                                ...additionalSubjectDetails,
                              },
                            };
                          },
                        ),
                      )
                      .then((notifications) => {
                        return notifications.filter((notification) => {
                          if (
                            !settings.showBots &&
                            notification.subject?.user.type === 'Bot'
                          ) {
                            return false;
                          }

                          return true;
                        });
                      }),
                  };
                }),
              )
              .then((parsedNotifications) => {
                setNotifications(parsedNotifications);
                triggerNativeNotifications(
                  notifications,
                  parsedNotifications,
                  settings,
                  accounts,
                );
                setIsFetching(false);
              });
          }),
        )
        .catch((err: AxiosError) => {
          let failureType: FailureType = 'UNKNOWN';

          const data = err.response.data as GithubRESTError;

          if (err.response.status === 401) {
            failureType = 'BAD_CREDENTIALS';
          } else if (err.response.status === 403) {
            if (data.message.includes("Missing the 'notifications' scope")) {
              failureType = 'MISSING_SCOPES';
            } else if (
              data.message.includes('API rate limit exceeded') ||
              data.message.includes('You have exceeded a secondary rate limit')
            ) {
              failureType = 'RATE_LIMITED';
            }
          }

          setIsFetching(false);
          setFailureType(failureType);
          setRequestFailed(true);
        });
    },
    [notifications],
  );

  const markNotificationRead = useCallback(
    async (accounts: AuthState, id: string, hostname: string) => {
      setIsFetching(true);

      const isEnterprise = isEnterpriseHost(hostname);
      const token = isEnterprise
        ? getEnterpriseAccountToken(hostname, accounts.enterpriseAccounts)
        : accounts.token;

      try {
        await apiRequestAuth(
          `${generateGitHubAPIUrl(hostname)}notifications/threads/${id}`,
          'PATCH',
          token,
          {},
        );

        const updatedNotifications = removeNotification(
          id,
          notifications,
          hostname,
        );

        setNotifications(updatedNotifications);
        setTrayIconColor(updatedNotifications);
        setIsFetching(false);
      } catch (err) {
        setIsFetching(false);
      }
    },
    [notifications],
  );

  const markNotificationDone = useCallback(
    async (accounts: AuthState, id: string, hostname: string) => {
      setIsFetching(true);

      const isEnterprise = isEnterpriseHost(hostname);
      const token = isEnterprise
        ? getEnterpriseAccountToken(hostname, accounts.enterpriseAccounts)
        : accounts.token;

      try {
        await apiRequestAuth(
          `${generateGitHubAPIUrl(hostname)}notifications/threads/${id}`,
          'DELETE',
          token,
          {},
        );

        const updatedNotifications = removeNotification(
          id,
          notifications,
          hostname,
        );

        setNotifications(updatedNotifications);
        setTrayIconColor(updatedNotifications);
        setIsFetching(false);
      } catch (err) {
        setIsFetching(false);
      }
    },
    [notifications],
  );

  const unsubscribeNotification = useCallback(
    async (accounts: AuthState, id: string, hostname: string) => {
      setIsFetching(true);

      const isEnterprise = isEnterpriseHost(hostname);
      const token = isEnterprise
        ? getEnterpriseAccountToken(hostname, accounts.enterpriseAccounts)
        : accounts.token;

      try {
        await apiRequestAuth(
          `${generateGitHubAPIUrl(
            hostname,
          )}notifications/threads/${id}/subscription`,
          'PUT',
          token,
          { ignored: true },
        );
        await markNotificationRead(accounts, id, hostname);
      } catch (err) {
        setIsFetching(false);
      }
    },
    [notifications],
  );

  const markRepoNotifications = useCallback(
    async (accounts: AuthState, repoSlug: string, hostname: string) => {
      setIsFetching(true);

      const isEnterprise = isEnterpriseHost(hostname);
      const token = isEnterprise
        ? getEnterpriseAccountToken(hostname, accounts.enterpriseAccounts)
        : accounts.token;

      try {
        await apiRequestAuth(
          `${generateGitHubAPIUrl(hostname)}repos/${repoSlug}/notifications`,
          'PUT',
          token,
          {},
        );

        const updatedNotifications = removeNotifications(
          repoSlug,
          notifications,
          hostname,
        );

        setNotifications(updatedNotifications);
        setTrayIconColor(updatedNotifications);
        setIsFetching(false);
      } catch (err) {
        setIsFetching(false);
      }
    },
    [notifications],
  );

  const markRepoNotificationsDone = useCallback(
    async (accounts: AuthState, repoSlug: string, hostname: string) => {
      setIsFetching(true);

      try {
        const accountIndex = notifications.findIndex(
          (accountNotifications) => accountNotifications.hostname === hostname,
        );

        if (accountIndex !== -1) {
          const notificationsToRemove = notifications[
            accountIndex
          ].notifications.filter(
            (notification) => notification.repository.full_name === repoSlug,
          );

          await Promise.all(
            notificationsToRemove.map((notification) =>
              markNotificationDone(
                accounts,
                notification.id,
                notifications[accountIndex].hostname,
              ),
            ),
          );
        }

        const updatedNotifications = removeNotifications(
          repoSlug,
          notifications,
          hostname,
        );

        setNotifications(updatedNotifications);
        setTrayIconColor(updatedNotifications);
        setIsFetching(false);
      } catch (err) {
        setIsFetching(false);
      }
    },
    [notifications],
  );

  const removeNotificationFromState = useCallback(
    (id: string, hostname: string) => {
      const updatedNotifications = removeNotification(
        id,
        notifications,
        hostname,
      );

      setNotifications(updatedNotifications);
      setTrayIconColor(updatedNotifications);
    },
    [notifications],
  );

  return {
    isFetching,
    requestFailed,
    failureType,
    notifications,

    removeNotificationFromState,
    fetchNotifications,
    markNotificationRead,
    markNotificationDone,
    unsubscribeNotification,
    markRepoNotifications,
    markRepoNotificationsDone,
  };
};

1	import axios, { AxiosError } from 'axios';	24✔
2	import { useCallback, useState } from 'react';	24✔
3
4	import {
5	AccountNotifications,
6	AuthState,
7	SettingsState,
8	FailureType,
9	} from '../types';
10	import { GithubRESTError, Notification } from '../typesGithub';
11	import { apiRequestAuth } from '../utils/api-requests';	24✔
12	import {	24✔
13	getEnterpriseAccountToken,
14	generateGitHubAPIUrl,
15	isEnterpriseHost,
16	getTokenForHost,
17	} from '../utils/helpers';
18	import { removeNotification } from '../utils/remove-notification';	24✔
19	import {	24✔
20	triggerNativeNotifications,
21	setTrayIconColor,
22	} from '../utils/notifications';
23	import Constants from '../utils/constants';	24✔
24	import { removeNotifications } from '../utils/remove-notifications';	24✔
25	import { getGitifySubjectDetails } from '../utils/subject';	24✔
26
27	interface NotificationsState {
28	notifications: AccountNotifications[];
29	removeNotificationFromState: (id: string, hostname: string) => void;
30	fetchNotifications: (
31	accounts: AuthState,
32	settings: SettingsState,
33	) => Promise<void>;
34	markNotificationRead: (
35	accounts: AuthState,
36	id: string,
37	hostname: string,
38	) => Promise<void>;
39	markNotificationDone: (
40	accounts: AuthState,
41	id: string,
42	hostname: string,
43	) => Promise<void>;
44	unsubscribeNotification: (
45	accounts: AuthState,
46	id: string,
47	hostname: string,
48	) => Promise<void>;
49	markRepoNotifications: (
50	accounts: AuthState,
51	repoSlug: string,
52	hostname: string,
53	) => Promise<void>;
54	markRepoNotificationsDone: (
55	accounts: AuthState,
56	repoSlug: string,
57	hostname: string,
58	) => Promise<void>;
59	isFetching: boolean;
60	requestFailed: boolean;
61	failureType: FailureType;
62	}
63
64	export const useNotifications = (colors: boolean): NotificationsState => {	24✔
65	const [isFetching, setIsFetching] = useState(false);	218✔
66	const [requestFailed, setRequestFailed] = useState(false);	218✔
67	const [failureType, setFailureType] = useState<FailureType>();	218✔
68
69	const [notifications, setNotifications] = useState<AccountNotifications[]>(	218✔
70	[],
71	);
72
73	const fetchNotifications = useCallback(	218✔
74	async (accounts: AuthState, settings: SettingsState) => {
75	const isGitHubLoggedIn = accounts.token !== null;	34✔
76	const endpointSuffix = `notifications?participating=${settings.participating}`;	34✔
77
78	function getGitHubNotifications() {
79	if (!isGitHubLoggedIn) {	34✔
80	return;	4✔
81	}
82	const url = `${generateGitHubAPIUrl(	30✔
83	Constants.DEFAULT_AUTH_OPTIONS.hostname,
84	)}${endpointSuffix}`;
85	return apiRequestAuth(url, 'GET', accounts.token);	30✔
86	}
87
88	function getEnterpriseNotifications() {
89	return accounts.enterpriseAccounts.map((account) => {	34✔
90	const url = `${generateGitHubAPIUrl(	18✔
91	account.hostname,
92	)}${endpointSuffix}`;
93	return apiRequestAuth(url, 'GET', account.token);	18✔
94	});
95	}
96
97	setIsFetching(true);	34✔
98	setFailureType(null);	34✔
99	setRequestFailed(false);	34✔
100
101	return axios	34✔
102	.all([getGitHubNotifications(), ...getEnterpriseNotifications()])
103	.then(
104	axios.spread((gitHubNotifications, ...entAccNotifications) => {
105	const enterpriseNotifications = entAccNotifications.map(	12✔
106	(accountNotifications) => {
107	const { hostname } = new URL(accountNotifications.config.url);	6✔
108	return {	6✔
109	hostname,
110	notifications: accountNotifications.data.map(
111	(notification: Notification) => {
112	return {	12✔
113	...notification,
114	hostname: hostname,
115	};
116	},
117	),
118	};
119	},
120	);
121	const data = isGitHubLoggedIn	12✔
122	? [
123	...enterpriseNotifications,
124	{
125	hostname: Constants.DEFAULT_AUTH_OPTIONS.hostname,
126	notifications: gitHubNotifications.data.map(
127	(notification: Notification) => {
128	return {	28✔
129	...notification,
130	hostname: Constants.DEFAULT_AUTH_OPTIONS.hostname,
131	};
132	},
133	),
134	},
135	]
136	: [...enterpriseNotifications];
137
138	if (colors === false) {	12✔
139	setNotifications(data);	8✔
140	triggerNativeNotifications(	8✔
141	notifications,
142	data,
143	settings,
144	accounts,
145	);
146	setIsFetching(false);	8✔
147	return;	8✔
148	}
149	axios	4✔
150	.all(
151	data.map(async (accountNotifications) => {
152	return {	4✔
153	hostname: accountNotifications.hostname,
154	notifications: await axios
155	.all<Notification>(
156	accountNotifications.notifications.map(
157	async (notification: Notification) => {
158	const token = getTokenForHost(	16✔
159	notification.hostname,
160	accounts,
161	);
162
163	const additionalSubjectDetails =
164	await getGitifySubjectDetails(	16✔
165	notification,
166	token,
167	);
168
169	return {	16✔
170	...notification,
171	subject: {
172	...notification.subject,
173	...additionalSubjectDetails,
174	},
175	};
176	},
177	),
178	)
179	.then((notifications) => {
180	return notifications.filter((notification) => {	4✔
181	if (	16✔
182	!settings.showBots &&	10✔
183	notification.subject?.user.type === 'Bot'
184	) {
185	return false;	2✔
186	}
187
188	return true;	14✔
189	});
190	}),
191	};
192	}),
193	)
194	.then((parsedNotifications) => {
195	setNotifications(parsedNotifications);	4✔
196	triggerNativeNotifications(	4✔
197	notifications,
198	parsedNotifications,
199	settings,
200	accounts,
201	);
202	setIsFetching(false);	4✔
203	});
204	}),
205	)
206	.catch((err: AxiosError) => {
207	let failureType: FailureType = 'UNKNOWN';	22✔
208
209	const data = err.response.data as GithubRESTError;	22✔
210
211	if (err.response.status === 401) {	22✔
212	failureType = 'BAD_CREDENTIALS';	4✔
213	} else if (err.response.status === 403) {	18✔
214	if (data.message.includes("Missing the 'notifications' scope")) {	12✔
215	failureType = 'MISSING_SCOPES';	4✔
216	} else if (	8✔
217	data.message.includes('API rate limit exceeded') \|\|	6✔
218	data.message.includes('You have exceeded a secondary rate limit')
219	) {
220	failureType = 'RATE_LIMITED';	8✔
221	}
222	}
223
224	setIsFetching(false);	22✔
225	setFailureType(failureType);	22✔
226	setRequestFailed(true);	22✔
227	});
228	},
229	[notifications],
230	);
231
232	const markNotificationRead = useCallback(	218✔
233	async (accounts: AuthState, id: string, hostname: string) => {
234	setIsFetching(true);	10✔
235
236	const isEnterprise = isEnterpriseHost(hostname);	10✔
237	const token = isEnterprise	10✔
238	? getEnterpriseAccountToken(hostname, accounts.enterpriseAccounts)
239	: accounts.token;
240
241	try {	10✔
242	await apiRequestAuth(	10✔
243	`${generateGitHubAPIUrl(hostname)}notifications/threads/${id}`,
244	'PATCH',
245	token,
246	{},
247	);
248
249	const updatedNotifications = removeNotification(	4✔
250	id,
251	notifications,
252	hostname,
253	);
254
255	setNotifications(updatedNotifications);	4✔
256	setTrayIconColor(updatedNotifications);	4✔
257	setIsFetching(false);	4✔
258	} catch (err) {
259	setIsFetching(false);	6✔
260	}
261	},
262	[notifications],
263	);
264
265	const markNotificationDone = useCallback(	218✔
266	async (accounts: AuthState, id: string, hostname: string) => {
267	setIsFetching(true);	8✔
268
269	const isEnterprise = isEnterpriseHost(hostname);	8✔
270	const token = isEnterprise	8✔
271	? getEnterpriseAccountToken(hostname, accounts.enterpriseAccounts)
272	: accounts.token;
273
274	try {	8✔
275	await apiRequestAuth(	8✔
276	`${generateGitHubAPIUrl(hostname)}notifications/threads/${id}`,
277	'DELETE',
278	token,
279	{},
280	);
281
282	const updatedNotifications = removeNotification(	2✔
283	id,
284	notifications,
285	hostname,
286	);
287
288	setNotifications(updatedNotifications);	2✔
289	setTrayIconColor(updatedNotifications);	2✔
290	setIsFetching(false);	2✔
291	} catch (err) {
292	setIsFetching(false);	6✔
293	}
294	},
295	[notifications],
296	);
297
298	const unsubscribeNotification = useCallback(	218✔
299	async (accounts: AuthState, id: string, hostname: string) => {
300	setIsFetching(true);	8✔
301
302	const isEnterprise = isEnterpriseHost(hostname);	8✔
303	const token = isEnterprise	8✔
304	? getEnterpriseAccountToken(hostname, accounts.enterpriseAccounts)
305	: accounts.token;
306
307	try {	8✔
308	await apiRequestAuth(	8✔
309	`${generateGitHubAPIUrl(
310	hostname,
311	)}notifications/threads/${id}/subscription`,
312	'PUT',
313	token,
314	{ ignored: true },
315	);
316	await markNotificationRead(accounts, id, hostname);	2✔
317	} catch (err) {
318	setIsFetching(false);	6✔
319	}
320	},
321	[notifications],
322	);
323
324	const markRepoNotifications = useCallback(	218✔
325	async (accounts: AuthState, repoSlug: string, hostname: string) => {
326	setIsFetching(true);	8✔
327
328	const isEnterprise = isEnterpriseHost(hostname);	8✔
329	const token = isEnterprise	8✔
330	? getEnterpriseAccountToken(hostname, accounts.enterpriseAccounts)
331	: accounts.token;
332
333	try {	8✔
334	await apiRequestAuth(	8✔
335	`${generateGitHubAPIUrl(hostname)}repos/${repoSlug}/notifications`,
336	'PUT',
337	token,
338	{},
339	);
340
341	const updatedNotifications = removeNotifications(	2✔
342	repoSlug,
343	notifications,
344	hostname,
345	);
346
347	setNotifications(updatedNotifications);	2✔
348	setTrayIconColor(updatedNotifications);	2✔
349	setIsFetching(false);	2✔
350	} catch (err) {
351	setIsFetching(false);	6✔
352	}
353	},
354	[notifications],
355	);
356
357	const markRepoNotificationsDone = useCallback(	218✔
358	async (accounts: AuthState, repoSlug: string, hostname: string) => {
359	setIsFetching(true);	8✔
360
361	try {	8✔
362	const accountIndex = notifications.findIndex(	8✔
UNCOV 363	(accountNotifications) => accountNotifications.hostname === hostname,	×
364	);
365
366	if (accountIndex !== -1) {	8!
UNCOV 367	const notificationsToRemove = notifications[	×
368	accountIndex
369	].notifications.filter(
UNCOV 370	(notification) => notification.repository.full_name === repoSlug,	×
371	);
372
UNCOV 373	await Promise.all(	×
374	notificationsToRemove.map((notification) =>
UNCOV 375	markNotificationDone(	×
376	accounts,
377	notification.id,
378	notifications[accountIndex].hostname,
379	),
380	),
381	);
382	}
383
384	const updatedNotifications = removeNotifications(	8✔
385	repoSlug,
386	notifications,
387	hostname,
388	);
389
390	setNotifications(updatedNotifications);	8✔
391	setTrayIconColor(updatedNotifications);	8✔
392	setIsFetching(false);	8✔
393	} catch (err) {
UNCOV 394	setIsFetching(false);	×
395	}
396	},
397	[notifications],
398	);
399
400	const removeNotificationFromState = useCallback(	218✔
401	(id: string, hostname: string) => {
402	const updatedNotifications = removeNotification(	2✔
403	id,
404	notifications,
405	hostname,
406	);
407
408	setNotifications(updatedNotifications);	2✔
409	setTrayIconColor(updatedNotifications);	2✔
410	},
411	[notifications],
412	);
413
414	return {	218✔
415	isFetching,
416	requestFailed,
417	failureType,
418	notifications,
419
420	removeNotificationFromState,
421	fetchNotifications,
422	markNotificationRead,
423	markNotificationDone,
424	unsubscribeNotification,
425	markRepoNotifications,
426	markRepoNotificationsDone,
427	};
428	};

gitify-app / gitify / 8580860003

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