Paths

Table of Contentst

-
services/identity/src/
-
identity/
-
src/
1/2
client_service.rs
1/2
database.rs
1/2
ddb_utils.rs
-
grpc_services/
1/2
authenticated.rs
-
grpc_utils.rs

Differential D11951

Refactor get user identifier to return identity with farcaster id
ClosedPublic
Actions

Authored by will on May 8 2024, 10:32 PM.

Details

Reviewers

bartek
kamil

Commits

rCOMM9a2f04e09c7f: Refactor get user identifier to return identity with farcaster id

Summary

This includes a new identity struct with a farcaster id field which we refactor get_user_identifier to return. This follows discussion from
https://linear.app/comm/issue/ENG-7759/modify-finduseridentity-to-take-list-of-userids-and-include-fid.

Depends on D11859

Test Plan

cargo check

Diff Detail

Repository

rCOMM Comm

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

will created this revision.May 8 2024, 10:32 PM

Herald added subscribers: tomek, ashoat. · View Herald TranscriptMay 8 2024, 10:32 PM

will retitled this revision from Refactor Identifier to include farcaster id to Refactor get user identifier to return identity with farcaster id.May 8 2024, 10:33 PM

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

will added a parent revision: D11859: [lib] Rename action type to set aux user fids.

will added inline comments.May 8 2024, 10:42 PM

services/identity/src/database.rs
25 ↗	(On Diff #39959)	Decided to name this DBIdentity to avoid confusion with proto Identity message. Let me know if there's an alternative name I could use

will added a child revision: D11952: [identity] modify get user identity rpc to take user ids and return identity map with farcaster id.May 8 2024, 10:43 PM

Harbormaster completed remote builds in B28772: Diff 39959.May 8 2024, 10:49 PM

will requested review of this revision.May 8 2024, 10:49 PM

Technically it looks okay. I like the renames you did. Just please apply the inline comment

services/identity/src/ddb_utils.rs
193–195 ↗	(On Diff #39959)	I think it should be merged. This way, it gets `None` when the attribute doesn't exist, but still fail when parsing fails (e.g. it's not a `String`)

This revision is now accepted and ready to land.May 8 2024, 11:12 PM

review feedback

Harbormaster completed remote builds in B28946: Diff 40230.May 15 2024, 8:47 AM

Closed by commit rCOMM9a2f04e09c7f: Refactor get user identifier to return identity with farcaster id (authored by will). · Explain WhyMay 15 2024, 8:30 PM

This revision was automatically updated to reflect the committed changes.

will added a commit: rCOMM9a2f04e09c7f: Refactor get user identifier to return identity with farcaster id.

Revision Contents
Changeset List

Path

Size

services/

identity/

src/

client_service.rs

16 lines

database.rs

8 lines

ddb_utils.rs

27 lines

grpc_services/

authenticated.rs

6 lines

grpc_utils.rs

7 lines

Diff 40230

View Options

services/identity/src/client_service.rs

// @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

services/identity/src/database.rs