diff --git a/src/hooks/useShortMentionsList.ts b/src/hooks/useShortMentionsList.ts index 1a7ee7c0dd31..aed1497cb111 100644 --- a/src/hooks/useShortMentionsList.ts +++ b/src/hooks/useShortMentionsList.ts @@ -1,10 +1,52 @@ -import {usePersonalDetails} from '@components/OnyxListItemProvider'; - import {getEmailDomain, isDomainPublic} from '@libs/LoginUtils'; +import memoize from '@libs/memoize'; + +import ONYXKEYS from '@src/ONYXKEYS'; +import {emailSelector} from '@src/selectors/Session'; +import type {PersonalDetailsList} from '@src/types/onyx'; + +import type {OnyxEntry} from 'react-native-onyx'; import {useMemo} from 'react'; +// eslint-disable-next-line no-restricted-imports +import {useOnyx as originalUseOnyx} from 'react-native-onyx'; import useCurrentUserPersonalDetails from './useCurrentUserPersonalDetails'; +import useOnyx from './useOnyx'; + +const emptyLoginsList: string[] = []; + +// One shared scan for all hook instances, cached by collection reference and login so it runs once +// per Onyx write. 'shallow' compares the cache key by reference; the default 'deep' would walk the +// whole collection on every lookup. +const buildAvailableLoginsList = memoize( + (personalDetails: OnyxEntry, currentUserLogin: string): string[] => { + if (!personalDetails) { + return emptyLoginsList; + } + + const currentUserDomain = getEmailDomain(currentUserLogin); + if (isDomainPublic(currentUserDomain)) { + return emptyLoginsList; + } + + const availableLogins: string[] = []; + for (const personalDetail of Object.values(personalDetails)) { + // Matching the current user's domain means the login is on the same private domain, + // because the public-domain case returned early above. + if (!personalDetail?.login || getEmailDomain(personalDetail.login) !== currentUserDomain) { + continue; + } + + const [username] = personalDetail.login.split('@'); + if (username) { + availableLogins.push(username); + } + } + return availableLogins; + }, + {maxSize: 1, equality: 'shallow', monitoringName: 'buildAvailableLoginsList'}, +); /** * This hook returns data to be used with short mentions in LiveMarkdown/Composer. @@ -13,38 +55,14 @@ import useCurrentUserPersonalDetails from './useCurrentUserPersonalDetails'; * In addition, currently logged-in user is returned separately since it requires special styling. */ export default function useShortMentionsList() { - const personalDetails = usePersonalDetails(); const currentUserPersonalDetails = useCurrentUserPersonalDetails(); + const [currentUserLogin = ''] = useOnyx(ONYXKEYS.SESSION, {selector: emailSelector}); - const availableLoginsList = useMemo(() => { - if (!personalDetails) { - return []; - } - - const currentUserDomain = getEmailDomain(currentUserPersonalDetails.login ?? ''); - if (isDomainPublic(currentUserDomain)) { - return []; - } - - return Object.values(personalDetails) - .map((personalDetail) => { - if (!personalDetail?.login) { - return; - } - - const personalDetailDomain = getEmailDomain(personalDetail.login); - const isPersonalDetailPublicDomain = isDomainPublic(personalDetailDomain); - - // If the emails are not in the same private domain, we don't want to highlight them - if (isPersonalDetailPublicDomain || personalDetailDomain !== currentUserDomain) { - return; - } - - const [username] = personalDetail.login.split('@'); - return username; - }) - .filter((login): login is string => !!login); - }, [currentUserPersonalDetails.login, personalDetails]); + // The selector output is compared by value, so consumers re-render only when the list changes. + // The raw hook skips the search-snapshot redirect: this list must always read live data. + const [availableLoginsList = emptyLoginsList] = originalUseOnyx(ONYXKEYS.PERSONAL_DETAILS_LIST, { + selector: (personalDetails) => buildAvailableLoginsList(personalDetails, currentUserLogin), + }); // We want to highlight both short and long version of current user login const currentUserMentions = useMemo(() => { diff --git a/tests/unit/hooks/useShortMentionsList.test.ts b/tests/unit/hooks/useShortMentionsList.test.ts new file mode 100644 index 000000000000..c07c3bd22c1e --- /dev/null +++ b/tests/unit/hooks/useShortMentionsList.test.ts @@ -0,0 +1,96 @@ +import {renderHook, waitFor} from '@testing-library/react-native'; + +import useShortMentionsList from '@hooks/useShortMentionsList'; + +import ONYXKEYS from '@src/ONYXKEYS'; + +import Onyx from 'react-native-onyx'; + +import waitForBatchedUpdates from '../../utils/waitForBatchedUpdates'; + +const ACCOUNT_ID_CURRENT_USER = 1; +const ACCOUNT_ID_COWORKER = 2; +const ACCOUNT_ID_STRANGER = 3; +const ACCOUNT_ID_NEW_HIRE = 4; + +const personalDetailsList = { + [ACCOUNT_ID_CURRENT_USER]: {accountID: ACCOUNT_ID_CURRENT_USER, login: 'user@acme.com'}, + [ACCOUNT_ID_COWORKER]: {accountID: ACCOUNT_ID_COWORKER, login: 'coworker@acme.com'}, + [ACCOUNT_ID_STRANGER]: {accountID: ACCOUNT_ID_STRANGER, login: 'stranger@gmail.com'}, +}; + +describe('useShortMentionsList', () => { + beforeAll(() => { + Onyx.init({keys: ONYXKEYS}); + }); + + beforeEach(async () => { + await Onyx.clear(); + await Onyx.merge(ONYXKEYS.SESSION, {email: 'user@acme.com', accountID: ACCOUNT_ID_CURRENT_USER}); + await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, personalDetailsList); + }); + + it('returns usernames sharing the current user private domain', async () => { + const {result} = renderHook(() => useShortMentionsList()); + + await waitFor(() => { + expect(result.current.availableLoginsList).toEqual(['user', 'coworker']); + }); + }); + + it('returns an empty list when the current user switches to a public domain', async () => { + const {result} = renderHook(() => useShortMentionsList()); + + await waitFor(() => { + expect(result.current.availableLoginsList).toEqual(['user', 'coworker']); + }); + + await Onyx.merge(ONYXKEYS.SESSION, {email: 'user@gmail.com'}); + + await waitFor(() => { + expect(result.current.availableLoginsList).toEqual([]); + }); + }); + + it('shares one computed list across instances and does not re-render on unrelated personal details writes', async () => { + let renderCount = 0; + const first = renderHook(() => { + renderCount++; + return useShortMentionsList(); + }); + const second = renderHook(() => useShortMentionsList()); + + await waitFor(() => { + expect(first.result.current.availableLoginsList).toEqual(['user', 'coworker']); + }); + + expect(second.result.current.availableLoginsList).toBe(first.result.current.availableLoginsList); + + const listBefore = first.result.current.availableLoginsList; + const rendersBefore = renderCount; + + await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, { + [ACCOUNT_ID_COWORKER]: {avatar: 'https://example.com/new-avatar.png'}, + }); + await waitForBatchedUpdates(); + + expect(first.result.current.availableLoginsList).toBe(listBefore); + expect(renderCount).toBe(rendersBefore); + }); + + it('updates when someone joins the domain', async () => { + const {result} = renderHook(() => useShortMentionsList()); + + await waitFor(() => { + expect(result.current.availableLoginsList).toEqual(['user', 'coworker']); + }); + + await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, { + [ACCOUNT_ID_NEW_HIRE]: {accountID: ACCOUNT_ID_NEW_HIRE, login: 'newcomer@acme.com'}, + }); + + await waitFor(() => { + expect(result.current.availableLoginsList).toEqual(['user', 'coworker', 'newcomer']); + }); + }); +});