9715573983

Committed 28 Jun 2024 03:59PM UTC coverage: 97.056% (+0.007%) from 97.049%

Build # 9715573983

Build Type

Pull #1321

github

Committed by

web-flow

Commit Message

Merge 4cd437058 into 80fb3d71f

Pull Request Pull Request #1321: feat: reset to default settings

Run Details

494 of 506 branches covered (97.63%)

Branch coverage included in aggregate %.

17 of 17 new or added lines in 2 files covered. (100.0%)

8 existing lines in 2 files now uncovered.

1286 of 1328 relevant lines covered (96.84%)

23.64 hits per line

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

72.55

/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,
  GroupBy,
  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,
  groupBy: GroupBy.REPOSITORY,
};

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;
  resetSettings: () => 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 account changes
  useEffect(() => {
    fetchNotifications({ auth, settings });
  }, [auth.accounts]);

  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 resetSettings = useCallback(() => {
    setSettings(defaultSettings);
    saveState({ auth, settings: defaultSettings });
  }, [auth]);

  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,
        resetSettings,
      }}
    >
      {children}
    </AppContext.Provider>
  );
};

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

gitify-app / gitify / 9715573983

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