Page MenuHomePhabricator
Differential D11953

[web] Make find user identities available to client
AbandonedPublicDraft
Actions

Authored by will on May 8 2024, 10:50 PM.
Tags
None
Referenced Files
Unknown Object (File)
Fri, Mar 7, 9:26 AM
Unknown Object (File)
Mar 3 2025, 4:41 PM
Unknown Object (File)
Feb 28 2025, 4:54 PM
Unknown Object (File)
Feb 28 2025, 4:53 PM
Unknown Object (File)
Feb 18 2025, 7:21 AM
Unknown Object (File)
Feb 15 2025, 3:17 AM
Unknown Object (File)
Jan 24 2025, 8:43 PM
Unknown Object (File)
Jan 24 2025, 8:43 PM
View All 49 Files
Subscribers
ashoat
tomek

Details

Reviewers
kamil
bartek
Summary

This provides access to the find user identities rpc on the clients

Depends on D11952

Test Plan

In progress. Will not land until I've tested on native that the rpc can successfully be called and returns Identity object

Diff Detail

Repository
rCOMM Comm
Branch
farcaster/set_aux_user_fids
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

will created this revision.May 8 2024, 10:50 PM
Herald added subscribers: tomek, ashoat. · View Herald TranscriptMay 8 2024, 10:50 PM
will added inline comments.May 8 2024, 10:53 PM
lib/types/identity-service-types.js
236–245

Appended an Object suffix to these names to match the protobuf code they are being set to :

export type IdentityObject = {
  username: string,
  ethIdentity: ?EthereumIdentityObject,
  farcasterId: ?string,
}

Unsure if we should drop the suffix and call these EthereumIdentity and Identity as they will have the same exact fields as their protobuf counterparts

Harbormaster returned this revision to the author for changes because remote builds failed.May 8 2024, 11:03 PM
Harbormaster failed remote builds in B28774: Diff 39961!
will abandoned this revision.May 10 2024, 9:53 PM
will removed a parent revision: D11952: [identity] modify get user identity rpc to take user ids and return identity map with farcaster id.

Revision Contents
Changeset List

Diff 39961

View Options

lib/types/identity-service-types.js

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines processDMOperation: async (
dmOperation: DMJoinThreadOperation, dmOperation: DMJoinThreadOperation,
viewerID: string, viewerID: string,
utilities: ProcessDMOperationUtilities, utilities: ProcessDMOperationUtilities,
) => { ) => {
const { joinerID, time, messageID, existingThreadDetails } = dmOperation; const { joinerID, time, messageID, existingThreadDetails } = dmOperation;
const currentThreadInfo = const currentThreadInfo =
utilities.threadInfos[existingThreadDetails.threadID]; utilities.threadInfos[existingThreadDetails.threadID];
if (currentThreadInfo && !currentThreadInfo.thick) {
return {
rawMessageInfos: [],
updateInfos: [],
};
}
const messageData = createMessageDataFromDMOperation(dmOperation); const messageData = createMessageDataFromDMOperation(dmOperation);
const joinThreadMessageInfos = [ const joinThreadMessageInfos = [
rawMessageInfoFromMessageData(messageData, messageID), rawMessageInfoFromMessageData(messageData, messageID),
]; ];
if (userIsMember(currentThreadInfo, joinerID)) { const memberTimestamps = { ...currentThreadInfo?.timestamps?.members };
if (!memberTimestamps[joinerID]) {
memberTimestamps[joinerID] = {
isMember: time,
subscription: existingThreadDetails.creationTime,
};
}
if (memberTimestamps[joinerID].isMember > time) {
inkaUnsubmitted
Not Done
Inline Actions

Same as in the previous diff we should probably handle timestamp collision

inka: Same as in the previous diff we should probably handle timestamp collision
tomekAuthorUnsubmitted
Done
Inline Actions

https://linear.app/comm/issue/ENG-9159/thick-threads-timestamps-conflict-resolution

tomek: https://linear.app/comm/issue/ENG-9159/thick-threads-timestamps-conflict-resolution
return { return {
rawMessageInfos: joinThreadMessageInfos, rawMessageInfos: joinThreadMessageInfos,
updateInfos: [], updateInfos: [],
}; };
} }
memberTimestamps[joinerID] = {
...memberTimestamps[joinerID],
isMember: time,
};
const updateInfos: Array<ClientUpdateInfo> = []; const updateInfos: Array<ClientUpdateInfo> = [];
const rawMessageInfos: Array<RawMessageInfo> = []; const rawMessageInfos: Array<RawMessageInfo> = [];
if (viewerID === joinerID) {
if (userIsMember(currentThreadInfo, joinerID)) {
rawMessageInfos.push(...joinThreadMessageInfos);
updateInfos.push({
type: updateTypes.UPDATE_THREAD,
id: uuid.v4(),
time,
threadInfo: {
...currentThreadInfo,
timestamps: {
...currentThreadInfo.timestamps,
members: memberTimestamps,
},
},
});
} else if (viewerID === joinerID) {
const newThreadInfo = createThickRawThreadInfo( const newThreadInfo = createThickRawThreadInfo(
{ {
...existingThreadDetails, ...existingThreadDetails,
allMemberIDsWithSubscriptions: [ allMemberIDsWithSubscriptions: [
...existingThreadDetails.allMemberIDsWithSubscriptions, ...existingThreadDetails.allMemberIDsWithSubscriptions,
{ id: joinerID, subscription: joinThreadSubscription }, { id: joinerID, subscription: joinThreadSubscription },
], ],
}, },
viewerID, viewerID,
); );
updateInfos.push({ updateInfos.push({
type: updateTypes.JOIN_THREAD, type: updateTypes.JOIN_THREAD,
id: uuid.v4(), id: uuid.v4(),
time, time,
threadInfo: newThreadInfo, threadInfo: {
...newThreadInfo,
timestamps: {
...newThreadInfo.timestamps,
members: memberTimestamps,
},
},
rawMessageInfos: joinThreadMessageInfos, rawMessageInfos: joinThreadMessageInfos,
truncationStatus: messageTruncationStatus.EXHAUSTIVE, truncationStatus: messageTruncationStatus.EXHAUSTIVE,
rawEntryInfos: [], rawEntryInfos: [],
}); });
} else { } else {
invariant(currentThreadInfo.thick, 'Thread should be thick');
rawMessageInfos.push(...joinThreadMessageInfos); rawMessageInfos.push(...joinThreadMessageInfos);
const defaultRoleID = values(currentThreadInfo.roles).find(role => const defaultRoleID = values(currentThreadInfo.roles).find(role =>
roleIsDefaultRole(role), roleIsDefaultRole(role),
)?.id; )?.id;
invariant(defaultRoleID, 'Default role ID must exist'); invariant(defaultRoleID, 'Default role ID must exist');
const { membershipPermissions } = createRoleAndPermissionForThickThreads( const { membershipPermissions } = createRoleAndPermissionForThickThreads(
currentThreadInfo.type, currentThreadInfo.type,
currentThreadInfo.id, currentThreadInfo.id,
defaultRoleID, defaultRoleID,
); );
const member = minimallyEncodeMemberInfo<ThickMemberInfo>({ const member = minimallyEncodeMemberInfo<ThickMemberInfo>({
id: joinerID, id: joinerID,
role: defaultRoleID, role: defaultRoleID,
permissions: membershipPermissions, permissions: membershipPermissions,
isSender: joinerID === viewerID, isSender: joinerID === viewerID,
subscription: joinThreadSubscription, subscription: joinThreadSubscription,
}); });
const updatedThreadInfo = { const updatedThreadInfo = {
...currentThreadInfo, ...currentThreadInfo,
members: [...currentThreadInfo.members, member], members: [...currentThreadInfo.members, member],
timestamps: {
...currentThreadInfo.timestamps,
members: memberTimestamps,
},
}; };
updateInfos.push({ updateInfos.push({
type: updateTypes.UPDATE_THREAD, type: updateTypes.UPDATE_THREAD,
id: uuid.v4(), id: uuid.v4(),
time, time,
threadInfo: updatedThreadInfo, threadInfo: updatedThreadInfo,
}); });
} }
return { return {
rawMessageInfos, rawMessageInfos,
updateInfos, updateInfos,
}; };
}, },
canBeProcessed( canBeProcessed(
dmOperation: DMJoinThreadOperation, dmOperation: DMJoinThreadOperation,
viewerID: string, viewerID: string,
utilities: ProcessDMOperationUtilities, utilities: ProcessDMOperationUtilities,
) { ) {
if (utilities.threadInfos[dmOperation.existingThreadDetails.threadID]) { if (
utilities.threadInfos[dmOperation.existingThreadDetails.threadID] ||
dmOperation.joinerID === viewerID
) {
return { isProcessingPossible: true }; return { isProcessingPossible: true };
} }
return { return {
isProcessingPossible: false, isProcessingPossible: false,
reason: { reason: {
type: 'missing_thread', type: 'missing_thread',
threadID: dmOperation.existingThreadDetails.threadID, threadID: dmOperation.existingThreadDetails.threadID,
}, },
}; };
}, },
supportsAutoRetry: true, supportsAutoRetry: true,
}); });
export { joinThreadSpec }; export { joinThreadSpec };
View Options

web/grpc/identity-service-client-wrapper.js

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines processDMOperation: async (
dmOperation: DMJoinThreadOperation, dmOperation: DMJoinThreadOperation,
viewerID: string, viewerID: string,
utilities: ProcessDMOperationUtilities, utilities: ProcessDMOperationUtilities,
) => { ) => {
const { joinerID, time, messageID, existingThreadDetails } = dmOperation; const { joinerID, time, messageID, existingThreadDetails } = dmOperation;
const currentThreadInfo = const currentThreadInfo =
utilities.threadInfos[existingThreadDetails.threadID]; utilities.threadInfos[existingThreadDetails.threadID];
if (currentThreadInfo && !currentThreadInfo.thick) {
return {
rawMessageInfos: [],
updateInfos: [],
};
}
const messageData = createMessageDataFromDMOperation(dmOperation); const messageData = createMessageDataFromDMOperation(dmOperation);
const joinThreadMessageInfos = [ const joinThreadMessageInfos = [
rawMessageInfoFromMessageData(messageData, messageID), rawMessageInfoFromMessageData(messageData, messageID),
]; ];
if (userIsMember(currentThreadInfo, joinerID)) { const memberTimestamps = { ...currentThreadInfo?.timestamps?.members };
if (!memberTimestamps[joinerID]) {
memberTimestamps[joinerID] = {
isMember: time,
subscription: existingThreadDetails.creationTime,
};
}
if (memberTimestamps[joinerID].isMember > time) {
inkaUnsubmitted
Not Done
Inline Actions

Same as in the previous diff we should probably handle timestamp collision

inka: Same as in the previous diff we should probably handle timestamp collision
tomekAuthorUnsubmitted
Done
Inline Actions

https://linear.app/comm/issue/ENG-9159/thick-threads-timestamps-conflict-resolution

tomek: https://linear.app/comm/issue/ENG-9159/thick-threads-timestamps-conflict-resolution
return { return {
rawMessageInfos: joinThreadMessageInfos, rawMessageInfos: joinThreadMessageInfos,
updateInfos: [], updateInfos: [],
}; };
} }
memberTimestamps[joinerID] = {
...memberTimestamps[joinerID],
isMember: time,
};
const updateInfos: Array<ClientUpdateInfo> = []; const updateInfos: Array<ClientUpdateInfo> = [];
const rawMessageInfos: Array<RawMessageInfo> = []; const rawMessageInfos: Array<RawMessageInfo> = [];
if (viewerID === joinerID) {
if (userIsMember(currentThreadInfo, joinerID)) {
rawMessageInfos.push(...joinThreadMessageInfos);
updateInfos.push({
type: updateTypes.UPDATE_THREAD,
id: uuid.v4(),
time,
threadInfo: {
...currentThreadInfo,
timestamps: {
...currentThreadInfo.timestamps,
members: memberTimestamps,
},
},
});
} else if (viewerID === joinerID) {
const newThreadInfo = createThickRawThreadInfo( const newThreadInfo = createThickRawThreadInfo(
{ {
...existingThreadDetails, ...existingThreadDetails,
allMemberIDsWithSubscriptions: [ allMemberIDsWithSubscriptions: [
...existingThreadDetails.allMemberIDsWithSubscriptions, ...existingThreadDetails.allMemberIDsWithSubscriptions,
{ id: joinerID, subscription: joinThreadSubscription }, { id: joinerID, subscription: joinThreadSubscription },
], ],
}, },
viewerID, viewerID,
); );
updateInfos.push({ updateInfos.push({
type: updateTypes.JOIN_THREAD, type: updateTypes.JOIN_THREAD,
id: uuid.v4(), id: uuid.v4(),
time, time,
threadInfo: newThreadInfo, threadInfo: {
...newThreadInfo,
timestamps: {
...newThreadInfo.timestamps,
members: memberTimestamps,
},
},
rawMessageInfos: joinThreadMessageInfos, rawMessageInfos: joinThreadMessageInfos,
truncationStatus: messageTruncationStatus.EXHAUSTIVE, truncationStatus: messageTruncationStatus.EXHAUSTIVE,
rawEntryInfos: [], rawEntryInfos: [],
}); });
} else { } else {
invariant(currentThreadInfo.thick, 'Thread should be thick');
rawMessageInfos.push(...joinThreadMessageInfos); rawMessageInfos.push(...joinThreadMessageInfos);
const defaultRoleID = values(currentThreadInfo.roles).find(role => const defaultRoleID = values(currentThreadInfo.roles).find(role =>
roleIsDefaultRole(role), roleIsDefaultRole(role),
)?.id; )?.id;
invariant(defaultRoleID, 'Default role ID must exist'); invariant(defaultRoleID, 'Default role ID must exist');
const { membershipPermissions } = createRoleAndPermissionForThickThreads( const { membershipPermissions } = createRoleAndPermissionForThickThreads(
currentThreadInfo.type, currentThreadInfo.type,
currentThreadInfo.id, currentThreadInfo.id,
defaultRoleID, defaultRoleID,
); );
const member = minimallyEncodeMemberInfo<ThickMemberInfo>({ const member = minimallyEncodeMemberInfo<ThickMemberInfo>({
id: joinerID, id: joinerID,
role: defaultRoleID, role: defaultRoleID,
permissions: membershipPermissions, permissions: membershipPermissions,
isSender: joinerID === viewerID, isSender: joinerID === viewerID,
subscription: joinThreadSubscription, subscription: joinThreadSubscription,
}); });
const updatedThreadInfo = { const updatedThreadInfo = {
...currentThreadInfo, ...currentThreadInfo,
members: [...currentThreadInfo.members, member], members: [...currentThreadInfo.members, member],
timestamps: {
...currentThreadInfo.timestamps,
members: memberTimestamps,
},
}; };
updateInfos.push({ updateInfos.push({
type: updateTypes.UPDATE_THREAD, type: updateTypes.UPDATE_THREAD,
id: uuid.v4(), id: uuid.v4(),
time, time,
threadInfo: updatedThreadInfo, threadInfo: updatedThreadInfo,
}); });
} }
return { return {
rawMessageInfos, rawMessageInfos,
updateInfos, updateInfos,
}; };
}, },
canBeProcessed( canBeProcessed(
dmOperation: DMJoinThreadOperation, dmOperation: DMJoinThreadOperation,
viewerID: string, viewerID: string,
utilities: ProcessDMOperationUtilities, utilities: ProcessDMOperationUtilities,
) { ) {
if (utilities.threadInfos[dmOperation.existingThreadDetails.threadID]) { if (
utilities.threadInfos[dmOperation.existingThreadDetails.threadID] ||
dmOperation.joinerID === viewerID
) {
return { isProcessingPossible: true }; return { isProcessingPossible: true };
} }
return { return {
isProcessingPossible: false, isProcessingPossible: false,
reason: { reason: {
type: 'missing_thread', type: 'missing_thread',
threadID: dmOperation.existingThreadDetails.threadID, threadID: dmOperation.existingThreadDetails.threadID,
}, },
}; };
}, },
supportsAutoRetry: true, supportsAutoRetry: true,
}); });
export { joinThreadSpec }; export { joinThreadSpec };
View Options

web/grpc/identity-service-context-provider.react.js

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines processDMOperation: async (
dmOperation: DMJoinThreadOperation, dmOperation: DMJoinThreadOperation,
viewerID: string, viewerID: string,
utilities: ProcessDMOperationUtilities, utilities: ProcessDMOperationUtilities,
) => { ) => {
const { joinerID, time, messageID, existingThreadDetails } = dmOperation; const { joinerID, time, messageID, existingThreadDetails } = dmOperation;
const currentThreadInfo = const currentThreadInfo =
utilities.threadInfos[existingThreadDetails.threadID]; utilities.threadInfos[existingThreadDetails.threadID];
if (currentThreadInfo && !currentThreadInfo.thick) {
return {
rawMessageInfos: [],
updateInfos: [],
};
}
const messageData = createMessageDataFromDMOperation(dmOperation); const messageData = createMessageDataFromDMOperation(dmOperation);
const joinThreadMessageInfos = [ const joinThreadMessageInfos = [
rawMessageInfoFromMessageData(messageData, messageID), rawMessageInfoFromMessageData(messageData, messageID),
]; ];
if (userIsMember(currentThreadInfo, joinerID)) { const memberTimestamps = { ...currentThreadInfo?.timestamps?.members };
if (!memberTimestamps[joinerID]) {
memberTimestamps[joinerID] = {
isMember: time,
subscription: existingThreadDetails.creationTime,
};
}
if (memberTimestamps[joinerID].isMember > time) {
inkaUnsubmitted
Not Done
Inline Actions

Same as in the previous diff we should probably handle timestamp collision

inka: Same as in the previous diff we should probably handle timestamp collision
tomekAuthorUnsubmitted
Done
Inline Actions

https://linear.app/comm/issue/ENG-9159/thick-threads-timestamps-conflict-resolution

tomek: https://linear.app/comm/issue/ENG-9159/thick-threads-timestamps-conflict-resolution
return { return {
rawMessageInfos: joinThreadMessageInfos, rawMessageInfos: joinThreadMessageInfos,
updateInfos: [], updateInfos: [],
}; };
} }
memberTimestamps[joinerID] = {
...memberTimestamps[joinerID],
isMember: time,
};
const updateInfos: Array<ClientUpdateInfo> = []; const updateInfos: Array<ClientUpdateInfo> = [];
const rawMessageInfos: Array<RawMessageInfo> = []; const rawMessageInfos: Array<RawMessageInfo> = [];
if (viewerID === joinerID) {
if (userIsMember(currentThreadInfo, joinerID)) {
rawMessageInfos.push(...joinThreadMessageInfos);
updateInfos.push({
type: updateTypes.UPDATE_THREAD,
id: uuid.v4(),
time,
threadInfo: {
...currentThreadInfo,
timestamps: {
...currentThreadInfo.timestamps,
members: memberTimestamps,
},
},
});
} else if (viewerID === joinerID) {
const newThreadInfo = createThickRawThreadInfo( const newThreadInfo = createThickRawThreadInfo(
{ {
...existingThreadDetails, ...existingThreadDetails,
allMemberIDsWithSubscriptions: [ allMemberIDsWithSubscriptions: [
...existingThreadDetails.allMemberIDsWithSubscriptions, ...existingThreadDetails.allMemberIDsWithSubscriptions,
{ id: joinerID, subscription: joinThreadSubscription }, { id: joinerID, subscription: joinThreadSubscription },
], ],
}, },
viewerID, viewerID,
); );
updateInfos.push({ updateInfos.push({
type: updateTypes.JOIN_THREAD, type: updateTypes.JOIN_THREAD,
id: uuid.v4(), id: uuid.v4(),
time, time,
threadInfo: newThreadInfo, threadInfo: {
...newThreadInfo,
timestamps: {
...newThreadInfo.timestamps,
members: memberTimestamps,
},
},
rawMessageInfos: joinThreadMessageInfos, rawMessageInfos: joinThreadMessageInfos,
truncationStatus: messageTruncationStatus.EXHAUSTIVE, truncationStatus: messageTruncationStatus.EXHAUSTIVE,
rawEntryInfos: [], rawEntryInfos: [],
}); });
} else { } else {
invariant(currentThreadInfo.thick, 'Thread should be thick');
rawMessageInfos.push(...joinThreadMessageInfos); rawMessageInfos.push(...joinThreadMessageInfos);
const defaultRoleID = values(currentThreadInfo.roles).find(role => const defaultRoleID = values(currentThreadInfo.roles).find(role =>
roleIsDefaultRole(role), roleIsDefaultRole(role),
)?.id; )?.id;
invariant(defaultRoleID, 'Default role ID must exist'); invariant(defaultRoleID, 'Default role ID must exist');
const { membershipPermissions } = createRoleAndPermissionForThickThreads( const { membershipPermissions } = createRoleAndPermissionForThickThreads(
currentThreadInfo.type, currentThreadInfo.type,
currentThreadInfo.id, currentThreadInfo.id,
defaultRoleID, defaultRoleID,
); );
const member = minimallyEncodeMemberInfo<ThickMemberInfo>({ const member = minimallyEncodeMemberInfo<ThickMemberInfo>({
id: joinerID, id: joinerID,
role: defaultRoleID, role: defaultRoleID,
permissions: membershipPermissions, permissions: membershipPermissions,
isSender: joinerID === viewerID, isSender: joinerID === viewerID,
subscription: joinThreadSubscription, subscription: joinThreadSubscription,
}); });
const updatedThreadInfo = { const updatedThreadInfo = {
...currentThreadInfo, ...currentThreadInfo,
members: [...currentThreadInfo.members, member], members: [...currentThreadInfo.members, member],
timestamps: {
...currentThreadInfo.timestamps,
members: memberTimestamps,
},
}; };
updateInfos.push({ updateInfos.push({
type: updateTypes.UPDATE_THREAD, type: updateTypes.UPDATE_THREAD,
id: uuid.v4(), id: uuid.v4(),
time, time,
threadInfo: updatedThreadInfo, threadInfo: updatedThreadInfo,
}); });
} }
return { return {
rawMessageInfos, rawMessageInfos,
updateInfos, updateInfos,
}; };
}, },
canBeProcessed( canBeProcessed(
dmOperation: DMJoinThreadOperation, dmOperation: DMJoinThreadOperation,
viewerID: string, viewerID: string,
utilities: ProcessDMOperationUtilities, utilities: ProcessDMOperationUtilities,
) { ) {
if (utilities.threadInfos[dmOperation.existingThreadDetails.threadID]) { if (
utilities.threadInfos[dmOperation.existingThreadDetails.threadID] ||
dmOperation.joinerID === viewerID
) {
return { isProcessingPossible: true }; return { isProcessingPossible: true };
} }
return { return {
isProcessingPossible: false, isProcessingPossible: false,
reason: { reason: {
type: 'missing_thread', type: 'missing_thread',
threadID: dmOperation.existingThreadDetails.threadID, threadID: dmOperation.existingThreadDetails.threadID,
}, },
}; };
}, },
supportsAutoRetry: true, supportsAutoRetry: true,
}); });
export { joinThreadSpec }; export { joinThreadSpec };