9672630513

Committed 26 Jun 2024 02:31AM UTC coverage: 97.029% (-0.02%) from 97.049%

Build # 9672630513

Build Type

Pull #1304

github

Committed by

web-flow

Commit Message

Merge bba5e8286 into cf7cd5003

Pull Request Pull Request #1304: feat: new filters route

Run Details

506 of 519 branches covered (97.5%)

Branch coverage included in aggregate %.

45 of 46 new or added lines in 6 files covered. (97.83%)

11 existing lines in 1 file now uncovered.

1323 of 1366 relevant lines covered (96.85%)

26.04 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,
  GroupBy,
  type SettingsState,
  type SettingsValue,
  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,
  filterReasons: [],
};

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

gitify-app / gitify / 9672630513

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