Page MenuHomePhabricator
Differential D12293

[lib] Inline `innerThreadFrozenDueToBlock` in `threadFrozenDueToBlock`
ClosedPublic
Actions

Authored by atul on Jun 3 2024, 1:54 PM.
Tags
None
Referenced Files
Unknown Object (File)
Thu, Mar 6, 7:30 AM
Unknown Object (File)
Thu, Mar 6, 7:30 AM
Unknown Object (File)
Thu, Mar 6, 7:30 AM
Unknown Object (File)
Thu, Mar 6, 7:30 AM
Unknown Object (File)
Thu, Mar 6, 7:30 AM
Unknown Object (File)
Feb 23 2025, 11:35 AM
Unknown Object (File)
Jan 30 2025, 9:51 AM
Unknown Object (File)
Jan 19 2025, 9:43 AM
View All 79 Files
Subscribers
None

Details

Reviewers
ashoat
ginsu
tomek
varun
Commits
rCOMM0050bc8a8abe: [lib] Inline `innerThreadFrozenDueToBlock` in `threadFrozenDueToBlock`
Summary

threadFrozenDueToBlock was last callsite of innerThreadFrozenDueToBlock, so inlining and removing innerThreadFrozenDueToBlock altogether.

Depends on D12292

Test Plan

flow + close reading

Diff Detail

Repository
rCOMM Comm
Branch
master
Lint
No Lint Coverage
Unit
No Test Coverage

Revision Contents
Changeset List

PathSize
lib/
shared/
13 lines

Diff 40902

View Options

lib/shared/thread-utils.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 };