Paths

Table of Contentst

-
keyserver/addons/rust-node-addon/
-
addons/
-
rust-node-addon/
1/2
rust-binding-types.js
-
lib/types/
-
types/
1/2
identity-service-types.js

[lib] move a shared type to lib
ClosedPublic
Actions

Authored by varun on Sep 8 2023, 12:58 PM.

Details

Reviewers

atul
marcin

Commits

rCOMMc774123d9980: [lib] move a shared type to lib

Summary

This type is needed on native/web too so I'm moving it.

Depends on D9114

Test Plan

ran flow

Diff Detail

Repository

rCOMM Comm

Branch

native (branched from master)

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

varun created this revision.Sep 8 2023, 12:58 PM

Herald added subscribers: tomek, ashoat. · View Herald TranscriptSep 8 2023, 12:58 PM

varun published this revision for review.Sep 8 2023, 12:59 PM

Harbormaster completed remote builds in B22460: Diff 30878.Sep 8 2023, 1:15 PM

marcin accepted this revision.Sep 11 2023, 5:18 AM

marcin added inline comments.

lib/types/identity-service-types.js
1	Each time I am about to introduce new file I tend to ask myself whether it is possible to reuse already existing location and if it is would it be better to reuse or to introduce new file. How about putting this type into `account-types`? od merging it with `LogInResponse`?

This revision is now accepted and ready to land.Sep 11 2023, 5:18 AM

varun added a child revision: D9127: [native] rename fields in JSON serialized string to camelCase from snake_case.Sep 11 2023, 10:38 AM

ashoat added inline comments.Sep 12 2023, 10:31 AM

lib/types/identity-service-types.js
1	I don't think it's bad for it to be in a separate file. That said, the annotation at the top of the file needs a space (see suggested edit) As mentioned here, @varun please try to maintain consistency on small things like this in the future. As evidenced by @marcin missing this, we simply can't rely on diff reviewers to catch small nits like this – it's on the diff author to do their best to match existing conventions

tomek added inline comments.Sep 13 2023, 2:32 AM

lib/types/identity-service-types.js
1	Most of the IDEs allow creating templates for files. In my case, I've configured that each new js file has // @flow at the start. You can consider doing something similar.

varun added inline comments.Sep 13 2023, 10:59 AM

lib/types/identity-service-types.js
1	good tip!

Closed by commit rCOMMc774123d9980: [lib] move a shared type to lib (authored by varun). · Explain WhySep 13 2023, 11:18 AM

This revision was automatically updated to reflect the committed changes.

varun added a commit: rCOMMc774123d9980: [lib] move a shared type to lib.

Revision Contents
Changeset List

Path

Size

keyserver/

addons/

rust-node-addon/

rust-binding-types.js

6 lines

lib/

types/

identity-service-types.js

6 lines

Diff 30878

View Options

keyserver/addons/rust-node-addon/rust-binding-types.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/identity-service-types.js