Diff 45067

View Options

lib/facts/blob-service.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

lib/types/blob-service-types.js