9228985326

Committed 24 May 2024 07:27PM UTC coverage: 96.249% (-0.4%) from 96.642%

Build # 9228985326

Build Type

Pull #1139

github

Committed by

web-flow

Commit Message

Merge 56328f1d5 into 99c8a6771

Pull Request Pull Request #1139: feat(accounts): new account system

Run Details

396 of 409 branches covered (96.82%)

Branch coverage included in aggregate %.

106 of 120 new or added lines in 15 files covered. (88.33%)

3 existing lines in 1 file now uncovered.

1041 of 1084 relevant lines covered (96.03%)

20.11 hits per line

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

73.63

/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 AccountNotifications,
  type AuthState,
  type GitifyError,
  type SettingsState,
  type Status,
  Theme,
} from '../types';
import { headNotifications } from '../utils/api/client';
import { addAccount, authGitHub, getToken, getUserData } from '../utils/auth';
import { migrateAuthenticatedAccounts } from '../utils/auth/migration';
import type {
  AuthOptionsOAuthApp,
  AuthOptionsPersonalAccessToken,
} from '../utils/auth/types';
import { setAutoLaunch, 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 defaultAuthState: 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,
};

interface AppContextState {
  auth: AuthState;
  isLoggedIn: boolean;
  loginWithGitHubApp: () => void;
  loginWithOAuthApp: (data: AuthOptionsOAuthApp) => void;
  loginWithPersonalAccessToken: (data: AuthOptionsPersonalAccessToken) => void;
  logout: () => void;

  notifications: AccountNotifications[];
  status: Status;
  errorDetails: GitifyError;
  removeNotificationFromState: (
    settings: SettingsState,
    id: string,
    hostname: string,
  ) => void;
  fetchNotifications: () => Promise<void>;
  markNotificationRead: (id: string, hostname: string) => Promise<void>;
  markNotificationDone: (id: string, hostname: string) => Promise<void>;
  unsubscribeNotification: (id: string, hostname: string) => Promise<void>;
  markRepoNotifications: (id: string, hostname: string) => Promise<void>;
  markRepoNotificationsDone: (id: string, hostname: string) => 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>(defaultAuthState);
  const [settings, setSettings] = useState<SettingsState>(defaultSettings);
  const {
    fetchNotifications,
    notifications,
    errorDetails,
    status,
    removeNotificationFromState,
    markNotificationRead,
    markNotificationDone,
    unsubscribeNotification,
    markRepoNotifications,
    markRepoNotificationsDone,
  } = useNotifications();

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

  useEffect(() => {
    setTheme(settings.theme as 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,
    auth.accounts.length,
  ]);

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

  // biome-ignore lint/correctness/useExhaustiveDependencies: We need to update tray title when settings or notifications changes.
  useEffect(() => {
    const count = getNotificationCount(notifications);

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

  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, 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 updatedAccounts = addAccount(
      auth,
      'GitHub App',
      token,
      hostname,
      user,
    );
    setAuth(updatedAccounts);
    saveState(updatedAccounts, settings);
  }, [auth, settings]);

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

  const loginWithPersonalAccessToken = useCallback(
    async ({ token, hostname }: AuthOptionsPersonalAccessToken) => {
      await headNotifications(hostname, token);

      const user = await getUserData(token, hostname);
      const updatedAccounts = addAccount(
        auth,
        'Personal Access Token',
        token,
        hostname,
        user,
      );
      setAuth(updatedAccounts);
      saveState(updatedAccounts, settings);
    },
    [auth, settings],
  );

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

  const restoreSettings = useCallback(() => {
    // Migrate authenticated accounts
    migrateAuthenticatedAccounts();

    const existing = loadState();

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

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

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

  const markNotificationReadWithAccounts = useCallback(
    async (id: string, hostname: string) =>
      await markNotificationRead(auth, settings, id, hostname),
    [auth, notifications],
  );

  const markNotificationDoneWithAccounts = useCallback(
    async (id: string, hostname: string) =>
      await markNotificationDone(auth, settings, id, hostname),
    [auth, notifications],
  );

  const unsubscribeNotificationWithAccounts = useCallback(
    async (id: string, hostname: string) =>
      await unsubscribeNotification(auth, settings, id, hostname),
    [auth, notifications],
  );

  const markRepoNotificationsWithAccounts = useCallback(
    async (repoSlug: string, hostname: string) =>
      await markRepoNotifications(auth, settings, repoSlug, hostname),
    [auth, notifications],
  );

  const markRepoNotificationsDoneWithAccounts = useCallback(
    async (repoSlug: string, hostname: string) =>
      await markRepoNotificationsDone(auth, settings, repoSlug, hostname),
    [auth, notifications],
  );

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

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

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

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

gitify-app / gitify / 9228985326

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