Paths

Table of Contentst

-
lib/hooks/
-
hooks/
1/2
primary-device-hooks.js
-
native/account/registration/missing-registration-data/
-
account/
-
registration/
-
missing-registration-data/
1/2
missing-registration-data-handler.react.js

[lib] create a hook to check if device is primary
ClosedPublic
Actions

Authored by kamil on Nov 27 2024, 9:30 AM.

Details

Reviewers

bartek
tomek

Commits

rCOMM1c4a54aec179: [lib] create a hook to check if device is primary

Summary

The fact that this is asynchronous is painful but this is caused by ENG-8192.

Creatin hook to avoid code duplication

Test Plan

Log result and check if this works on primary and non-primary

Diff Detail

Repository

rCOMM Comm

Branch

backup-2

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

kamil created this revision.Nov 27 2024, 9:30 AM

kamil held this revision as a draft.

Herald added a subscriber: ashoat. · View Herald TranscriptNov 27 2024, 9:31 AM

kamil added a child revision: D14056: [native] enable backup handler for staff.Nov 27 2024, 9:36 AM

Harbormaster completed remote builds in B32885: Diff 46100.Nov 27 2024, 9:52 AM

kamil published this revision for review.Nov 27 2024, 10:17 AM

kamil edited the summary of this revision. (Show Details)

kamil mentioned this in D14063: [native] allow password change only on primary device.Nov 28 2024, 5:29 AM

bartek accepted this revision.Nov 29 2024, 3:16 AM

bartek added inline comments.

lib/hooks/primary-device-hooks.js
22	Alternatively, you can use `await getContentSigningKey()` from `lib/utils/crypto-utils.js` to get just deviceID and avoid relying on Identity context

This revision is now accepted and ready to land.Nov 29 2024, 3:16 AM

kamil added inline comments.Dec 2 2024, 6:53 AM

lib/hooks/primary-device-hooks.js
22	It's basically the same, but I prefer using `getAuthMetadata()` as this is what we use a lot more in the codebase. Overall, we should aim to get ENG-8192 done as a future solution.

Closed by commit rCOMM1c4a54aec179: [lib] create a hook to check if device is primary (authored by kamil). · Explain WhyDec 2 2024, 6:54 AM

This revision was automatically updated to reflect the committed changes.

kamil added a commit: rCOMM1c4a54aec179: [lib] create a hook to check if device is primary.

kamil mentioned this in rCOMM99f4e4a6ccef: [native] allow password change only on primary device.Dec 3 2024, 6:28 AM

Revision Contents
Changeset List

Path

Size

lib/

hooks/

primary-device-hooks.js

27 lines

native/

account/

registration/

missing-registration-data/

missing-registration-data-handler.react.js

27 lines

Diff 46100

View Options

lib/hooks/primary-device-hooks.js

// @flow // @flow

import * as React from 'react'; import * as React from 'react';

import { setAuxUserFIDsActionType } from '../actions/aux-user-actions.js';

import { import {

updateRelationships as serverUpdateRelationships, updateRelationships as serverUpdateRelationships,

updateRelationshipsActionTypes, updateRelationshipsActionTypes,

} from '../actions/relationship-actions.js'; } from '../actions/relationship-actions.js';

import { NeynarClientContext } from '../components/neynar-client-provider.react.js'; import { NeynarClientContext } from '../components/neynar-client-provider.react.js';

import { useLegacyAshoatKeyserverCall } from '../keyserver-conn/legacy-keyserver-call.js'; import { useLegacyAshoatKeyserverCall } from '../keyserver-conn/legacy-keyserver-call.js';

import { cookieSelector } from '../selectors/keyserver-selectors.js'; import { cookieSelector } from '../selectors/keyserver-selectors.js';

import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';

import { relationshipActions } from '../types/relationship-types.js'; import { relationshipActions } from '../types/relationship-types.js';

import { authoritativeKeyserverID } from '../utils/authoritative-keyserver.js'; import { authoritativeKeyserverID } from '../utils/authoritative-keyserver.js';

import { useCurrentUserFID } from '../utils/farcaster-utils.js'; import { useCurrentUserFID } from '../utils/farcaster-utils.js';

import { useDispatchActionPromise } from '../utils/redux-promise-utils.js'; import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';

import { useSelector } from '../utils/redux-utils.js'; import { useSelector, useDispatch } from '../utils/redux-utils.js';

import { usingCommServicesAccessToken } from '../utils/services-utils.js'; import { usingCommServicesAccessToken } from '../utils/services-utils.js';

function FarcasterDataHandler(): React.Node { function FarcasterDataHandler(): React.Node {

const isActive = useSelector(state => state.lifecycleState !== 'background'); const isActive = useSelector(state => state.lifecycleState !== 'background');

const cookie = useSelector(cookieSelector(authoritativeKeyserverID())); const cookie = useSelector(cookieSelector(authoritativeKeyserverID()));

const hasUserCookie = !!(cookie && cookie.startsWith('user=')); const hasUserCookie = !!(cookie && cookie.startsWith('user='));

const currentUserID = useSelector(state => state.currentUserInfo?.id); const currentUserID = useSelector(state => state.currentUserInfo?.id);

const loggedIn = !!currentUserID && hasUserCookie; const loggedIn = !!currentUserID && hasUserCookie;

const neynarClient = React.useContext(NeynarClientContext)?.client; const neynarClient = React.useContext(NeynarClientContext)?.client;

const identityServiceClient = React.useContext(IdentityClientContext); const identityServiceClient = React.useContext(IdentityClientContext);

const getFarcasterUsers = const getFarcasterUsers =

identityServiceClient?.identityClient.getFarcasterUsers; identityServiceClient?.identityClient.getFarcasterUsers;

const findUserIdentities =

identityServiceClient?.identityClient.findUserIdentities;

const dispatch = useDispatch();

const dispatchActionPromise = useDispatchActionPromise(); const dispatchActionPromise = useDispatchActionPromise();

const updateRelationships = useLegacyAshoatKeyserverCall( const updateRelationships = useLegacyAshoatKeyserverCall(

serverUpdateRelationships, serverUpdateRelationships,

); );

const createThreadsAndRobotextForFarcasterMutuals = React.useCallback( const createThreadsAndRobotextForFarcasterMutuals = React.useCallback(

(userIDsToFID: { +[userID: string]: string }) => (userIDsToFID: { +[userID: string]: string }) =>

updateRelationships({ updateRelationships({

action: relationshipActions.FARCASTER_MUTUAL, action: relationshipActions.FARCASTER_MUTUAL,

userIDsToFID, userIDsToFID,

}), }),

[updateRelationships], [updateRelationships],

); );

const userInfos = useSelector(state => state.userStore.userInfos); const userInfos = useSelector(state => state.userStore.userInfos);

const fid = useCurrentUserFID(); const fid = useCurrentUserFID();

const prevCanQueryRef = React.useRef<?boolean>(); const prevCanQueryRef = React.useRef<?boolean>();

React.useEffect(() => {

if (!usingCommServicesAccessToken) {

return;

}

const handleFarcasterMutuals = React.useCallback(async () => {

const canQuery = isActive && !!fid && loggedIn; const canQuery = isActive && !!fid && loggedIn;

if (canQuery === prevCanQueryRef.current) { if (canQuery === prevCanQueryRef.current) {

return; return;

} }

prevCanQueryRef.current = canQuery; prevCanQueryRef.current = canQuery;

if ( if (

!loggedIn || !loggedIn ||

!isActive || !isActive ||

!fid || !fid ||

!neynarClient || !neynarClient ||

!getFarcasterUsers || !getFarcasterUsers ||

!currentUserID !currentUserID

) { ) {

return; return;

} }

void (async () => {

const followerFIDs = await neynarClient.fetchFriendFIDs(fid); const followerFIDs = await neynarClient.fetchFriendFIDs(fid);

const commFCUsers = await getFarcasterUsers(followerFIDs); const commFCUsers = await getFarcasterUsers(followerFIDs);

const newCommUsers = commFCUsers.filter( const newCommUsers = commFCUsers.filter(({ userID }) => !userInfos[userID]);

({ userID }) => !userInfos[userID],

);

if (newCommUsers.length === 0) { if (newCommUsers.length === 0) {

return; return;

} }

const userIDsToFID: { +[userID: string]: string } = Object.fromEntries( const userIDsToFID: { +[userID: string]: string } = Object.fromEntries(

newCommUsers.map(({ userID, farcasterID }) => [userID, farcasterID]), newCommUsers.map(({ userID, farcasterID }) => [userID, farcasterID]),

); );

const userIDsToFIDIncludingCurrentUser: { +[userID: string]: string } = { const userIDsToFIDIncludingCurrentUser: { +[userID: string]: string } = {

...userIDsToFID, ...userIDsToFID,

[(currentUserID: string)]: fid, [(currentUserID: string)]: fid,

}; };

void dispatchActionPromise( void dispatchActionPromise(

updateRelationshipsActionTypes, updateRelationshipsActionTypes,

createThreadsAndRobotextForFarcasterMutuals( createThreadsAndRobotextForFarcasterMutuals(

userIDsToFIDIncludingCurrentUser, userIDsToFIDIncludingCurrentUser,

), ),

); );

})();

}, [ }, [

isActive, isActive,

fid, fid,

loggedIn, loggedIn,

neynarClient, neynarClient,

getFarcasterUsers, getFarcasterUsers,

userInfos, userInfos,

dispatchActionPromise, dispatchActionPromise,

createThreadsAndRobotextForFarcasterMutuals, createThreadsAndRobotextForFarcasterMutuals,

currentUserID, currentUserID,

]); ]);

const handleUserStoreFIDs = React.useCallback(async () => {

if (!loggedIn || !isActive || !findUserIdentities) {

return;

}

const userStoreIDs = Object.keys(userInfos);

const userIdentities = await findUserIdentities(userStoreIDs);

const userStoreFarcasterUsers = Object.entries(userIdentities)

.filter(([, identity]) => identity.farcasterID !== null)

.map(([userID, identity]) => ({

userID,

username: identity.username,

farcasterID: identity.farcasterID,

}));

dispatch({

type: setAuxUserFIDsActionType,

payload: {

farcasterUsers: userStoreFarcasterUsers,

});

willAuthorUnsubmitted

Done

I introduced a previous diff where setAuxUserFIDs now clears fids prior to updating with new fids from the payload. The previous functionality of setAuxUserFIDs of just adding without clearing is now a new action type addAuxUserFIDs

There are now two callbacks which are called by a single useEffect. The two callbacks are called handleFarcasterMutuals and handleUserStoreFIDs

will: I introduced a previous diff where `setAuxUserFIDs` now clears fids prior to updating with new…

}, [loggedIn, isActive, findUserIdentities, userInfos, dispatch]);

React.useEffect(() => {

if (!usingCommServicesAccessToken) {

return;

}

void (async () => {

await Promise.all([handleFarcasterMutuals(), handleUserStoreFIDs()]);

[]);

ashoatUnsubmitted

Not Done

return;

}

- void (async () => {

- await Promise.all([handleFarcasterMutuals(), handleUserStoreFIDs()]);

- },

- []);

+ void handleFarcasterMutuals();

+ void handleUserStoreFIDs();

}, [handleFarcasterMutuals, handleUserStoreFIDs]);

Line 145 isn't doing anything
Since we aren't waiting on these anyways, we can simplify this a little bit

ashoat: 1. Line 145 isn't doing anything 2. Since we aren't waiting on these anyways, we can simplify…

}, [handleFarcasterMutuals, handleUserStoreFIDs]);

return null; return null;

} }

export { FarcasterDataHandler }; export { FarcasterDataHandler };

View Options

native/account/registration/missing-registration-data/missing-registration-data-handler.react.js