Page MenuHomePhabricator
Differential D12370

[native/web] introduce migration to move local message info to sqlite
ClosedPublic
Actions

Authored by ginsu on Jun 9 2024, 11:02 PM.
Tags
None
Referenced Files
Unknown Object (File)
Mon, Mar 24, 12:31 PM
Unknown Object (File)
Thu, Mar 13, 7:15 PM
Unknown Object (File)
Thu, Mar 13, 7:15 PM
Unknown Object (File)
Thu, Mar 13, 7:15 PM
Unknown Object (File)
Thu, Mar 13, 7:15 PM
Unknown Object (File)
Thu, Mar 13, 7:15 PM
Unknown Object (File)
Thu, Mar 13, 7:15 PM
Unknown Object (File)
Thu, Mar 13, 7:15 PM
View All Files
Subscribers
ashoat
tomek
will

Details

Reviewers
tomek
kamil
will
Commits
rCOMM59f8c4f6cbd0: [native/web] introduce migration to move local message info to sqlite
Summary

This migration moves + saves any existing local message infos into sqlite

Depends on D12358

Test Plan

Created some failed sent local messages, ran migrations and confirmed that the there are db rows in the local message client db for each failed message. Double checked in redux dev tools that the migrations ran successfully and additionally assertMessageStoreLocalMessageInfosAreEqual (which gets introduced in the next diff in this stack) does not throw errors whenever I open the app

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

ginsu created this revision.Jun 9 2024, 11:02 PM
Herald added subscribers: tomek, ashoat. · View Herald TranscriptJun 9 2024, 11:03 PM
ginsu retitled this revision from [native/web] introduce migration to move local message info to sqlite to DRAFT [native/web] introduce migration to move local message info to sqlite.Jun 9 2024, 11:09 PM
ginsu edited the summary of this revision. (Show Details)
ginsu added a subscriber: will.
Harbormaster completed remote builds in B29563: Diff 41150.Jun 9 2024, 11:19 PM
ginsu requested review of this revision.Jun 9 2024, 11:19 PM
will added a child revision: D12384: [lib] assert function and setting client db with sqlite data.Jun 10 2024, 11:29 AM
ginsu updated this revision to Diff 41199.Jun 10 2024, 11:08 PM

update

ginsu edited the summary of this revision. (Show Details)Jun 10 2024, 11:15 PM
ginsu added a reviewer: tomek.
ginsu added a parent revision: D12358: [lib] update message reducer to use ops approach for local field.
Harbormaster completed remote builds in B29595: Diff 41199.Jun 10 2024, 11:25 PM
ginsu updated this revision to Diff 41229.Jun 11 2024, 10:34 PM

rebase

ginsu retitled this revision from DRAFT [native/web] introduce migration to move local message info to sqlite to [native/web] introduce migration to move local message info to sqlite.Jun 11 2024, 10:40 PM
ginsu edited the summary of this revision. (Show Details)
ginsu edited the test plan for this revision. (Show Details)
ginsu added reviewers: kamil, will.
ginsu edited the test plan for this revision. (Show Details)
Harbormaster completed remote builds in B29617: Diff 41229.Jun 11 2024, 10:49 PM
tomek accepted this revision.Jun 12 2024, 4:11 AM
This revision is now accepted and ready to land.Jun 12 2024, 4:11 AM
ginsu updated this revision to Diff 41246.Jun 12 2024, 11:30 AM

rebase before landing

Harbormaster completed remote builds in B29627: Diff 41246.Jun 12 2024, 11:46 AM
Closed by commit rCOMM59f8c4f6cbd0: [native/web] introduce migration to move local message info to sqlite (authored by ginsu). · Explain WhyJun 12 2024, 11:50 AM
This revision was automatically updated to reflect the committed changes.
ginsu added a commit: rCOMM59f8c4f6cbd0: [native/web] introduce migration to move local message info to sqlite.

Revision Contents
Changeset List

PathSize
native/
redux/
42 lines
web/
redux/
2 lines
49 lines

Diff 41150

View Options

native/redux/persist.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
Inline Actions

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
Inline Actions
return;
}
- void (async () => {
- await Promise.all([handleFarcasterMutuals(), handleUserStoreFIDs()]);
- },
- []);
+ void handleFarcasterMutuals();
+ void handleUserStoreFIDs();
}, [handleFarcasterMutuals, handleUserStoreFIDs]);
  1. Line 145 isn't doing anything
  2. 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

web/redux/persist-constants.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
Inline Actions

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
Inline Actions
return;
}
- void (async () => {
- await Promise.all([handleFarcasterMutuals(), handleUserStoreFIDs()]);
- },
- []);
+ void handleFarcasterMutuals();
+ void handleUserStoreFIDs();
}, [handleFarcasterMutuals, handleUserStoreFIDs]);
  1. Line 145 isn't doing anything
  2. 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

web/redux/persist.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
Inline Actions

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
Inline Actions
return;
}
- void (async () => {
- await Promise.all([handleFarcasterMutuals(), handleUserStoreFIDs()]);
- },
- []);
+ void handleFarcasterMutuals();
+ void handleUserStoreFIDs();
}, [handleFarcasterMutuals, handleUserStoreFIDs]);
  1. Line 145 isn't doing anything
  2. 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 };