9580541109

Committed 19 Jun 2024 10:36AM UTC coverage: 96.742% (-0.1%) from 96.891%

Build # 9580541109

Build Type

Pull #1273

github

Committed by

web-flow

Commit Message

Merge 9c29ba2ae into 0027d8488

Pull Request Pull Request #1273: feat: group notifications by repository or date

Run Details

471 of 483 branches covered (97.52%)

Branch coverage included in aggregate %.

10 of 12 new or added lines in 3 files covered. (83.33%)

9 existing lines in 2 files now uncovered.

1192 of 1236 relevant lines covered (96.44%)

22.4 hits per line

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

71.72

/src/context/App.tsx

import {
  type ReactNode,
  createContext,
  useCallback,
  useEffect,
  useMemo,
  useState,
} from 'react';
import { useInterval } from '../hooks/useInterval';
import { useNotifications } from '../hooks/useNotifications';
import {
  type Account,
  type AccountNotifications,
  type AuthState,
  type GitifyError,
  type SettingsState,
  type Status,
  Theme,
} from '../types';
import type { Notification } from '../typesGitHub';
import { headNotifications } from '../utils/api/client';
import { migrateAuthenticatedAccounts } from '../utils/auth/migration';
import type {
  LoginOAuthAppOptions,
  LoginPersonalAccessTokenOptions,
} from '../utils/auth/types';
import {
  addAccount,
  authGitHub,
  getToken,
  getUserData,
  removeAccount,
} from '../utils/auth/utils';
import {
  setAutoLaunch,
  setKeyboardShortcut,
  updateTrayTitle,
} from '../utils/comms';
import Constants from '../utils/constants';
import { getNotificationCount } from '../utils/notifications';
import { clearState, loadState, saveState } from '../utils/storage';
import { setTheme } from '../utils/theme';

const defaultAuth: AuthState = {
  accounts: [],
  token: null,
  enterpriseAccounts: [],
  user: null,
};

export const defaultSettings: SettingsState = {
  participating: false,
  playSound: true,
  showNotifications: true,
  showBots: true,
  showNotificationsCountInTray: false,
  openAtStartup: false,
  theme: Theme.SYSTEM,
  detailedNotifications: true,
  markAsDoneOnOpen: false,
  showAccountHostname: false,
  delayNotificationState: false,
  showPills: true,
  keyboardShortcut: true,
  groupByRepository: true,
};

interface AppContextState {
  auth: AuthState;
  isLoggedIn: boolean;
  loginWithGitHubApp: () => void;
  loginWithOAuthApp: (data: LoginOAuthAppOptions) => void;
  loginWithPersonalAccessToken: (data: LoginPersonalAccessTokenOptions) => void;
  logoutFromAccount: (account: Account) => void;
  logout: () => void;

  notifications: AccountNotifications[];
  status: Status;
  errorDetails: GitifyError;
  removeNotificationFromState: (
    settings: SettingsState,
    notification: Notification,
  ) => void;
  fetchNotifications: () => Promise<void>;
  markNotificationRead: (notification: Notification) => Promise<void>;
  markNotificationDone: (notification: Notification) => Promise<void>;
  unsubscribeNotification: (notification: Notification) => Promise<void>;
  markRepoNotificationsRead: (notification: Notification) => Promise<void>;
  markRepoNotificationsDone: (notification: Notification) => Promise<void>;

  settings: SettingsState;
  updateSetting: (
    name: keyof SettingsState,
    value: boolean | Theme | string | null,
  ) => void;
}

export const AppContext = createContext<Partial<AppContextState>>({});

export const AppProvider = ({ children }: { children: ReactNode }) => {
  const [auth, setAuth] = useState<AuthState>(defaultAuth);
  const [settings, setSettings] = useState<SettingsState>(defaultSettings);
  const {
    fetchNotifications,
    notifications,
    errorDetails,
    status,
    removeNotificationFromState,
    markNotificationRead,
    markNotificationDone,
    unsubscribeNotification,
    markRepoNotificationsRead,
    markRepoNotificationsDone,
  } = useNotifications();

  useEffect(() => {
    restoreSettings();
  }, []);

  useEffect(() => {
    setTheme(settings.theme);
  }, [settings.theme]);

  // biome-ignore lint/correctness/useExhaustiveDependencies: We only want fetchNotifications to be called for certain account or setting changes.
  useEffect(() => {
    fetchNotifications({ auth, settings });
  }, [
    settings.participating,
    settings.showBots,
    settings.detailedNotifications,
    settings.delayNotificationState,
    auth.accounts.length,
  ]);

  useInterval(() => {
    fetchNotifications({ auth, settings });
  }, Constants.FETCH_INTERVAL);

  useEffect(() => {
    const count = getNotificationCount(notifications);

    if (settings.showNotificationsCountInTray && count > 0) {
      updateTrayTitle(count.toString());
    } else {
      updateTrayTitle();
    }
  }, [settings.showNotificationsCountInTray, notifications]);

  useEffect(() => {
    setKeyboardShortcut(settings.keyboardShortcut);
  }, [settings.keyboardShortcut]);

  const updateSetting = useCallback(
    (name: keyof SettingsState, value: boolean | Theme) => {
      if (name === 'openAtStartup') {
        setAutoLaunch(value as boolean);
      }

      const newSettings = { ...settings, [name]: value };
      setSettings(newSettings);
      saveState({ auth, settings: newSettings });
    },
    [auth, settings],
  );

  const isLoggedIn = useMemo(() => {
    return auth.accounts.length > 0;
  }, [auth]);

  const loginWithGitHubApp = useCallback(async () => {
    const { authCode } = await authGitHub();
    const { token } = await getToken(authCode);
    const hostname = Constants.DEFAULT_AUTH_OPTIONS.hostname;
    const user = await getUserData(token, hostname);
    const updatedAuth = addAccount(auth, 'GitHub App', token, hostname, user);
    setAuth(updatedAuth);
    saveState({ auth: updatedAuth, settings });
  }, [auth, settings]);

  const loginWithOAuthApp = useCallback(
    async (data: LoginOAuthAppOptions) => {
      const { authOptions, authCode } = await authGitHub(data);
      const { token, hostname } = await getToken(authCode, authOptions);
      const user = await getUserData(token, hostname);
      const updatedAuth = addAccount(auth, 'OAuth App', token, hostname, user);
      setAuth(updatedAuth);
      saveState({ auth: updatedAuth, settings });
    },
    [auth, settings],
  );

  const loginWithPersonalAccessToken = useCallback(
    async ({ token, hostname }: LoginPersonalAccessTokenOptions) => {
      await headNotifications(hostname, token);
      const user = await getUserData(token, hostname);
      const updatedAuth = addAccount(
        auth,
        'Personal Access Token',
        token,
        hostname,
        user,
      );
      setAuth(updatedAuth);
      saveState({ auth: updatedAuth, settings });
    },
    [auth, settings],
  );

  const logoutFromAccount = useCallback(
    async (account: Account) => {
      const updatedAuth = removeAccount(auth, account);
      setAuth(updatedAuth);
      saveState({ auth: updatedAuth, settings });
    },
    [auth, settings],
  );

  const logout = useCallback(() => {
    setAuth(defaultAuth);
    clearState();
  }, []);

  const restoreSettings = useCallback(async () => {
    await migrateAuthenticatedAccounts();

    const existing = loadState();

    if (existing.auth) {
      setAuth({ ...defaultAuth, ...existing.auth });
    }

    if (existing.settings) {
      setKeyboardShortcut(existing.settings.keyboardShortcut);
      setSettings({ ...defaultSettings, ...existing.settings });
      return existing.settings;
    }
  }, []);

  const fetchNotificationsWithAccounts = useCallback(
    async () => await fetchNotifications({ auth, settings }),
    [auth, settings, fetchNotifications],
  );

  const markNotificationReadWithAccounts = useCallback(
    async (notification: Notification) =>
      await markNotificationRead({ auth, settings }, notification),
    [auth, settings, markNotificationRead],
  );

  const markNotificationDoneWithAccounts = useCallback(
    async (notification: Notification) =>
      await markNotificationDone({ auth, settings }, notification),
    [auth, settings, markNotificationDone],
  );

  const unsubscribeNotificationWithAccounts = useCallback(
    async (notification: Notification) =>
      await unsubscribeNotification({ auth, settings }, notification),
    [auth, settings, unsubscribeNotification],
  );

  const markRepoNotificationsReadWithAccounts = useCallback(
    async (notification: Notification) =>
      await markRepoNotificationsRead({ auth, settings }, notification),
    [auth, settings, markRepoNotificationsRead],
  );

  const markRepoNotificationsDoneWithAccounts = useCallback(
    async (notification: Notification) =>
      await markRepoNotificationsDone({ auth, settings }, notification),
    [auth, settings, markRepoNotificationsDone],
  );

  return (
    <AppContext.Provider
      value={{
        auth,
        isLoggedIn,
        loginWithGitHubApp,
        loginWithOAuthApp,
        loginWithPersonalAccessToken,
        logoutFromAccount,
        logout,

        notifications,
        status,
        errorDetails,
        removeNotificationFromState,
        fetchNotifications: fetchNotificationsWithAccounts,
        markNotificationRead: markNotificationReadWithAccounts,
        markNotificationDone: markNotificationDoneWithAccounts,
        unsubscribeNotification: unsubscribeNotificationWithAccounts,
        markRepoNotificationsRead: markRepoNotificationsReadWithAccounts,
        markRepoNotificationsDone: markRepoNotificationsDoneWithAccounts,

        settings,
        updateSetting,
      }}
    >
      {children}
    </AppContext.Provider>
  );
};

1	import {	26✔
2	type ReactNode,
3	createContext,
4	useCallback,
5	useEffect,
6	useMemo,
7	useState,
8	} from 'react';
9	import { useInterval } from '../hooks/useInterval';	26✔
10	import { useNotifications } from '../hooks/useNotifications';	26✔
11	import {	26✔
12	type Account,
13	type AccountNotifications,
14	type AuthState,
15	type GitifyError,
16	type SettingsState,
17	type Status,
18	Theme,
19	} from '../types';
20	import type { Notification } from '../typesGitHub';
21	import { headNotifications } from '../utils/api/client';	26✔
22	import { migrateAuthenticatedAccounts } from '../utils/auth/migration';	26✔
23	import type {
24	LoginOAuthAppOptions,
25	LoginPersonalAccessTokenOptions,
26	} from '../utils/auth/types';
27	import {	26✔
28	addAccount,
29	authGitHub,
30	getToken,
31	getUserData,
32	removeAccount,
33	} from '../utils/auth/utils';
34	import {	26✔
35	setAutoLaunch,
36	setKeyboardShortcut,
37	updateTrayTitle,
38	} from '../utils/comms';
39	import Constants from '../utils/constants';	26✔
40	import { getNotificationCount } from '../utils/notifications';	26✔
41	import { clearState, loadState, saveState } from '../utils/storage';	26✔
42	import { setTheme } from '../utils/theme';	26✔
43
44	const defaultAuth: AuthState = {	26✔
45	accounts: [],
46	token: null,
47	enterpriseAccounts: [],
48	user: null,
49	};
50
51	export const defaultSettings: SettingsState = {	26✔
52	participating: false,
53	playSound: true,
54	showNotifications: true,
55	showBots: true,
56	showNotificationsCountInTray: false,
57	openAtStartup: false,
58	theme: Theme.SYSTEM,
59	detailedNotifications: true,
60	markAsDoneOnOpen: false,
61	showAccountHostname: false,
62	delayNotificationState: false,
63	showPills: true,
64	keyboardShortcut: true,
65	groupByRepository: true,
66	};
67
68	interface AppContextState {
69	auth: AuthState;
70	isLoggedIn: boolean;
71	loginWithGitHubApp: () => void;
72	loginWithOAuthApp: (data: LoginOAuthAppOptions) => void;
73	loginWithPersonalAccessToken: (data: LoginPersonalAccessTokenOptions) => void;
74	logoutFromAccount: (account: Account) => void;
75	logout: () => void;
76
77	notifications: AccountNotifications[];
78	status: Status;
79	errorDetails: GitifyError;
80	removeNotificationFromState: (
81	settings: SettingsState,
82	notification: Notification,
83	) => void;
84	fetchNotifications: () => Promise<void>;
85	markNotificationRead: (notification: Notification) => Promise<void>;
86	markNotificationDone: (notification: Notification) => Promise<void>;
87	unsubscribeNotification: (notification: Notification) => Promise<void>;
88	markRepoNotificationsRead: (notification: Notification) => Promise<void>;
89	markRepoNotificationsDone: (notification: Notification) => Promise<void>;
90
91	settings: SettingsState;
92	updateSetting: (
93	name: keyof SettingsState,
94	value: boolean \| Theme \| string \| null,
95	) => void;
96	}
97
98	export const AppContext = createContext<Partial<AppContextState>>({});	26✔
99
100	export const AppProvider = ({ children }: { children: ReactNode }) => {	26✔
101	const [auth, setAuth] = useState<AuthState>(defaultAuth);	26✔
102	const [settings, setSettings] = useState<SettingsState>(defaultSettings);	26✔
103	const {
104	fetchNotifications,
105	notifications,
106	errorDetails,
107	status,
108	removeNotificationFromState,
109	markNotificationRead,
110	markNotificationDone,
111	unsubscribeNotification,
112	markRepoNotificationsRead,
113	markRepoNotificationsDone,
114	} = useNotifications();	26✔
115
116	useEffect(() => {	26✔
117	restoreSettings();	22✔
118	}, []);
119
120	useEffect(() => {	26✔
121	setTheme(settings.theme);	22✔
122	}, [settings.theme]);
123
124	// biome-ignore lint/correctness/useExhaustiveDependencies: We only want fetchNotifications to be called for certain account or setting changes.
125	useEffect(() => {	26✔
126	fetchNotifications({ auth, settings });	24✔
127	}, [
128	settings.participating,
129	settings.showBots,
130	settings.detailedNotifications,
131	settings.delayNotificationState,
132	auth.accounts.length,
133	]);
134
135	useInterval(() => {	26✔
136	fetchNotifications({ auth, settings });	6✔
137	}, Constants.FETCH_INTERVAL);
138
139	useEffect(() => {	26✔
140	const count = getNotificationCount(notifications);	22✔
141
142	if (settings.showNotificationsCountInTray && count > 0) {	22!
UNCOV 143	updateTrayTitle(count.toString());	×
144	} else {
145	updateTrayTitle();	22✔
146	}
147	}, [settings.showNotificationsCountInTray, notifications]);
148
149	useEffect(() => {	26✔
150	setKeyboardShortcut(settings.keyboardShortcut);	22✔
151	}, [settings.keyboardShortcut]);
152
153	const updateSetting = useCallback(	26✔
154	(name: keyof SettingsState, value: boolean \| Theme) => {
155	if (name === 'openAtStartup') {	4✔
156	setAutoLaunch(value as boolean);	2✔
157	}
158
159	const newSettings = { ...settings, [name]: value };	4✔
160	setSettings(newSettings);	4✔
161	saveState({ auth, settings: newSettings });	4✔
162	},
163	[auth, settings],
164	);
165
166	const isLoggedIn = useMemo(() => {	26✔
167	return auth.accounts.length > 0;	22✔
168	}, [auth]);
169
170	const loginWithGitHubApp = useCallback(async () => {	26✔
UNCOV 171	const { authCode } = await authGitHub();	×
172	const { token } = await getToken(authCode);	×
173	const hostname = Constants.DEFAULT_AUTH_OPTIONS.hostname;	×
174	const user = await getUserData(token, hostname);	×
175	const updatedAuth = addAccount(auth, 'GitHub App', token, hostname, user);	×
176	setAuth(updatedAuth);	×
177	saveState({ auth: updatedAuth, settings });	×
178	}, [auth, settings]);
179
180	const loginWithOAuthApp = useCallback(	26✔
181	async (data: LoginOAuthAppOptions) => {
UNCOV 182	const { authOptions, authCode } = await authGitHub(data);	×
183	const { token, hostname } = await getToken(authCode, authOptions);	×
184	const user = await getUserData(token, hostname);	×
185	const updatedAuth = addAccount(auth, 'OAuth App', token, hostname, user);	×
186	setAuth(updatedAuth);	×
187	saveState({ auth: updatedAuth, settings });	×
188	},
189	[auth, settings],
190	);
191
192	const loginWithPersonalAccessToken = useCallback(	26✔
193	async ({ token, hostname }: LoginPersonalAccessTokenOptions) => {
194	await headNotifications(hostname, token);	2✔
195	const user = await getUserData(token, hostname);	2✔
UNCOV 196	const updatedAuth = addAccount(	×
197	auth,
198	'Personal Access Token',
199	token,
200	hostname,
201	user,
202	);
UNCOV 203	setAuth(updatedAuth);	×
204	saveState({ auth: updatedAuth, settings });	×
205	},
206	[auth, settings],
207	);
208
209	const logoutFromAccount = useCallback(	26✔
210	async (account: Account) => {
UNCOV 211	const updatedAuth = removeAccount(auth, account);	×
212	setAuth(updatedAuth);	×
213	saveState({ auth: updatedAuth, settings });	×
214	},
215	[auth, settings],
216	);
217
218	const logout = useCallback(() => {	26✔
219	setAuth(defaultAuth);	2✔
220	clearState();	2✔
221	}, []);
222
223	const restoreSettings = useCallback(async () => {	26✔
224	await migrateAuthenticatedAccounts();	22✔
225
226	const existing = loadState();	22✔
227
228	if (existing.auth) {	22!
UNCOV 229	setAuth({ ...defaultAuth, ...existing.auth });	×
230	}
231
232	if (existing.settings) {	22!
UNCOV 233	setKeyboardShortcut(existing.settings.keyboardShortcut);	×
234	setSettings({ ...defaultSettings, ...existing.settings });	×
235	return existing.settings;	×
236	}
237	}, []);
238
239	const fetchNotificationsWithAccounts = useCallback(	26✔
240	async () => await fetchNotifications({ auth, settings }),	2✔
241	[auth, settings, fetchNotifications],
242	);
243
244	const markNotificationReadWithAccounts = useCallback(	26✔
245	async (notification: Notification) =>
246	await markNotificationRead({ auth, settings }, notification),	2✔
247	[auth, settings, markNotificationRead],
248	);
249
250	const markNotificationDoneWithAccounts = useCallback(	26✔
251	async (notification: Notification) =>
252	await markNotificationDone({ auth, settings }, notification),	2✔
253	[auth, settings, markNotificationDone],
254	);
255
256	const unsubscribeNotificationWithAccounts = useCallback(	26✔
257	async (notification: Notification) =>
258	await unsubscribeNotification({ auth, settings }, notification),	2✔
259	[auth, settings, unsubscribeNotification],
260	);
261
262	const markRepoNotificationsReadWithAccounts = useCallback(	26✔
263	async (notification: Notification) =>
264	await markRepoNotificationsRead({ auth, settings }, notification),	2✔
265	[auth, settings, markRepoNotificationsRead],
266	);
267
268	const markRepoNotificationsDoneWithAccounts = useCallback(	26✔
269	async (notification: Notification) =>
270	await markRepoNotificationsDone({ auth, settings }, notification),	2✔
271	[auth, settings, markRepoNotificationsDone],
272	);
273
274	return (	26✔
275	<AppContext.Provider
276	value={{
277	auth,
278	isLoggedIn,
279	loginWithGitHubApp,
280	loginWithOAuthApp,
281	loginWithPersonalAccessToken,
282	logoutFromAccount,
283	logout,
284
285	notifications,
286	status,
287	errorDetails,
288	removeNotificationFromState,
289	fetchNotifications: fetchNotificationsWithAccounts,
290	markNotificationRead: markNotificationReadWithAccounts,
291	markNotificationDone: markNotificationDoneWithAccounts,
292	unsubscribeNotification: unsubscribeNotificationWithAccounts,
293	markRepoNotificationsRead: markRepoNotificationsReadWithAccounts,
294	markRepoNotificationsDone: markRepoNotificationsDoneWithAccounts,
295
296	settings,
297	updateSetting,
298	}}
299	>
300	{children}
301	</AppContext.Provider>
302	);
303	};

gitify-app / gitify / 9580541109

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